# frozen_string_literal: true

module Dhall
	class Expression; end

	class Application < Expression
		def initialize(f, *args)
			if args.empty?
				raise ArgumentError, "Application requires at least one argument"
			end

			@f = f
			@args = args
		end
	end

	class Function < Expression
		def initialize(var, type, body)
			@var = var
			@type = type
			@body = body
		end
	end

	class Forall < Function; end

	class Bool < Expression
		def initialize(value)
			@value = value
		end
	end

	class Variable < Expression
		def initialize(var, index=0)
			@var = var
			@index = index
		end
	end

	class Operator < Expression
		def initialize(op, lhs, rhs)
			@op = op
			@lhs = lhs
			@rhs = rhs
		end
	end

	class List < Expression
		def initialize(*els)
			@els = els
		end
	end

	class EmptyList < List
		def initialize(type)
			@type = type
		end
	end

	class Optional < Expression
		def initialize(value, type=nil)
			raise TypeError, "value must not be nil" if value.nil?

			@value = value
			@type = type
		end
	end

	class OptionalNone < Optional
		def initialize(type)
			raise TypeError, "type must not be nil" if type.nil?

			@type = type
		end
	end

	class Merge < Expression
		def initialize(record, input, type)
			@record = record
			@input = input
			@type = type
		end
	end

	class RecordType < Expression
		def initialize(record)
			@record = record
		end
	end

	class Record < Expression
		def initialize(record)
			@record = record
		end
	end

	class RecordFieldAccess < Expression
		def initialize(record, field)
			raise TypeError, "field must be a String" unless field.is_a?(String)

			@record = record
			@field = field
		end
	end

	class RecordProjection < Expression
		def initialize(record, *fields)
			unless fields.all? { |x| x.is_a?(String) }
				raise TypeError, "fields must be String"
			end

			@record = record
			@fields = fields
		end
	end

	class UnionType < Expression
		def initialize(record)
			@record = record
		end
	end

	class Union < Expression
		def initialize(tag, value, rest_of_type)
			raise TypeError, "tag must be a string" unless tag.is_a?(String)

			@tag = tag
			@value = value
			@rest_of_type = rest_of_type
		end
	end

	class Constructors < Expression
		extend Gem::Deprecate

		def initialize(arg)
			@arg = arg
		end
		DEPRETATION_WIKI = "https://github.com/dhall-lang/dhall-lang/wiki/" \
		                   "Migration:-Deprecation-of-constructors-keyword"
		deprecate :initialize, DEPRECATION_WIKI, 2019, 4
	end

	class If < Expression
		def initialize(cond, thn, els)
			@cond = cond
			@thn = thn
			@els = els
		end
	end

	class Number < Expression
		def initialize(n)
			@n = n
		end
	end

	class Natural < Number; end
	class Integer < Number; end
	class Double < Number; end

	class Text < Expression
		def initialize(string)
			raise TypeError, "must be a String" unless string.is_a?(String)

			@string = string
		end
	end

	class TextLiteral < Text
		def initialize(*chunks)
			@chunks = chunks
		end
	end

	class Import < Expression
		def initialize(integrity_check, import_type, path)
			@integrity_check = integrity_check
			@import_type = import_type
			@path = path
		end

		class URI
			def initialize(headers, authority, *path, query, fragment)
				@headers = headers
				@authority = authority
				@path = path
				@query = query
				@fragment = fragment
			end
		end

		class Http < URI; end
		class Https < URI; end

		class Path
			def initialize(*path)
				@path = path
			end
		end

		class AbsolutePath < Path; end
		class RelativePath < Path; end
		class RelativeToParentPath < Path; end
		class RelativeToHomePath < Path; end

		class EnvironmentVariable
			def initialize(var)
				@var = var
			end
		end

		class MissingImport; end

		class IntegrityCheck
			def initialize(protocol, data)
				@protocol = protocol
				@data = data
			end
		end
	end

	class Let
		def initialize(var, assign, type=nil)
			@var = var
			@assign = assign
			@type = type
		end
	end

	class LetBlock < Expression
		def initialize(body, *lets)
			unless lets.all? { |x| x.is_a?(Let) }
				raise TypeError, "LetBlock only contains Let"
			end

			@lets = lets
			@body = body
		end
	end

	class TypeAnnotation < Expression
		def initialize(value, type)
			@value = value
			@type = type
		end
	end
end