# frozen_string_literal: true

module ROM
  module SQL
    module Postgres
      module Values
        Point = ::Struct.new(:x, :y)

        Line = ::Struct.new(:a, :b, :c)

        Circle = ::Struct.new(:center, :radius)

        Box = ::Struct.new(:upper_right, :lower_left)

        LineSegment = ::Struct.new(:begin, :end)

        Path = ::Struct.new(:points, :type) do
          def open?
            type == :open
          end

          def closed?
            type == :closed
          end

          def to_a
            points
          end
        end
      end

      # @api public
      module Types
        # The list of geometric data types supported by PostgreSQL
        # @see https://www.postgresql.org/docs/current/static/datatype-geometric.html

        Point = Type("point") do
          SQL::Types.define(Values::Point) do
            input do |point|
              "(#{point.x},#{point.y})"
            end

            output do |point|
              x, y = point.to_s[1...-1].split(",", 2)
              Values::Point.new(Float(x), Float(y))
            end
          end
        end

        Line = Type("line") do
          SQL::Types.define(Values::Line) do
            input do |line|
              "{#{line.a},#{line.b},#{line.c}}"
            end

            output do |line|
              a, b, c = line.to_s[1..-2].split(",", 3)
              Values::Line.new(Float(a), Float(b), Float(c))
            end
          end
        end

        Circle = Type("circle") do
          SQL::Types.define(Values::Circle) do
            input do |circle|
              "<(#{circle.center.x},#{circle.center.y}),#{circle.radius}>"
            end

            output do |circle|
              x, y, r = circle.to_s.tr("()<>", "").split(",", 3)
              center = Values::Point.new(Float(x), Float(y))
              Values::Circle.new(center, Float(r))
            end
          end
        end

        Box = Type("box") do
          SQL::Types.define(Values::Box) do
            input do |box|
              "((#{box.upper_right.x},#{box.upper_right.y}),"\
                "(#{box.lower_left.x},#{box.lower_left.y}))"
            end

            output do |box|
              x_right, y_right, x_left, y_left = box.to_s.tr("()", "").split(",", 4)
              upper_right = Values::Point.new(Float(x_right), Float(y_right))
              lower_left = Values::Point.new(Float(x_left), Float(y_left))
              Values::Box.new(upper_right, lower_left)
            end
          end
        end

        LineSegment = Type("lseg") do
          SQL::Types.define(Values::LineSegment) do
            input do |segment|
              "[(#{segment.begin.x},#{segment.begin.y}),"\
                "(#{segment.end.x},#{segment.end.y})]"
            end

            output do |segment|
              x_begin, y_begin, x_end, y_end = segment.to_s.tr("()[]", "").split(",", 4)
              point_begin = Values::Point.new(Float(x_begin), Float(y_begin))
              point_end = Values::Point.new(Float(x_end), Float(y_end))
              Values::LineSegment.new(point_begin, point_end)
            end
          end
        end

        Polygon = Type("polygon") do
          SQL::Types.define(::Array) do
            input do |points|
              points_joined = points.map { |p| "(#{p.x},#{p.y})" }.join(",")
              "(#{points_joined})"
            end

            output do |polygon|
              coordinates = polygon.to_s.tr("()", "").split(",").each_slice(2)
              coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }
            end
          end
        end

        Path = Type("path") do
          SQL::Types.define(Values::Path) do
            input do |path|
              points_joined = path.to_a.map { |p| "(#{p.x},#{p.y})" }.join(",")

              if path.open?
                "[#{points_joined}]"
              else
                "(#{points_joined})"
              end
            end

            output do |path|
              open = path.to_s.start_with?("[") && path.to_s.end_with?("]")
              coordinates = path.to_s.tr("()[]", "").split(",").each_slice(2)
              points = coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }

              if open
                Values::Path.new(points, :open)
              else
                Values::Path.new(points, :closed)
              end
            end
          end
        end
      end
    end
  end
end