# SmqlToAR - Parser: Converts SMQL to ActiveRecord
# Copyright (C) 2011 Denis Knauf
# 
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

class SmqlToAR
	#############################################################################
	# Alle Subklassen (qualitativ: ConditionTypes::*), die als Superklasse Condition haben,
	#  stellen eine Regel dar,  unter diesen sie das gesuchte Objekt annehmen.
	# Nimmt eine solche Klasse ein Object nicht an,  so wird die naechste Klasse ausprobiert.
	# Es wird in der Reihenfolge abgesucht,  in der #constants die Klassen liefert,
	#  wobei angenommen wird,  dass diese nach dem Erstellungszeitpunkt sortiert sind,
	#  aeltere zuerst.
	# Nimmt eine Klasse ein Objekt an,  so soll diese Klasse instanziert werden.
	# Alles weitere siehe Condition.
	module ConditionTypes
		class <<self
			# Ex: 'givenname|surname|nick' => [:givenname, :surname, :nick]
			def split_keys k
				k.split( '|').collect &:to_sym
			end

			# Eine Regel parsen.
			# Ex: Person, "givenname=", "Peter"
			def try_parse_it model, colop, val
				r = nil
				#p :try_parse => { :model => model, :colop => colop, :value => val }
				constants.each do |c|
					next  if :Condition == c
					c = const_get c
					next  if Condition === c
					raise UnexpectedColOpError.new( model, colop, val)  unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/
					col, op = $1, $2
					col = split_keys( col).collect {|c| Column.new model, c }
					r = c.try_parse model, col, op, val
					break  if r
				end
				raise UnexpectedError.new( model, colop, val)  unless r
				r
			end

			# Alle Regeln parsen.  Die Regeln sind in einem Hash der Form {colop => val}
			# Ex: Person, {"givenname=", "Peter", "surname=", "Mueller"}
			def try_parse model, colopvals
				colopvals.collect do |colop, val|
					#p :try_parse => { colop: colop, val: val, model: model }
					try_parse_it model, colop, val
				end
			rescue SMQLError => e
				raise SubSMQLError.new( colopvals, model, e)
			end

			# Erstellt eine Condition fuer eine Regel.
			def simple_condition superclass, op = nil, where = nil, expected = nil
				cl = Class.new superclass
				cl.const_set :Operator, op  if op
				cl.const_set :Where, where  if where
				cl.const_set :Expected, expected  if expected
				cl
			end
		end

		class Condition
			attr_reader :value, :cols
			Operator = nil
			Expected = []
			Where = nil

			# Versuche das Objekt zu erkennen.  Operator und Expected muessen passen.
			# Passt das Object,  die Klasse instanzieren.
			def self.try_parse model, cols, op, val
				#p :self => name, :try_parse => op, :cols => cols, :with => self::Operator, :value => val, :expected => self::Expected, :model => model.name
				new model, cols, val  if self::Operator === op and self::Expected.any? {|i| i === val }
			end

			def initialize model, cols, val
				@model, @cols = model, cols
				@value = case val
					when Hash, Range then val
					else Array.wrap val
					end
				verify
			end

			def verify
				@cols.each do |col|
					verify_column col
					verify_allowed col
				end
			end

			# Gibt es eine Spalte diesen Namens?
			# Oder:  Gibt es eine Relation diesen Namens?  (Hier nicht der Fall)
			def verify_column col
				raise NonExistingColumnError.new( %w[Column], col)  unless col.exist_in?
			end

			# Modelle koennen Spalten/Relationen verbieten mit Model#smql_protected.
			# Dieses muss ein Object mit #include?( name_als_string) zurueckliefern,
			# welches true fuer verboten und false fuer, erlaubt steht.
			def verify_allowed col
				raise ProtectedColumnError.new( col)  if col.protected?
			end

			# Erstelle alle noetigen Klauseln. builder nimmt diese entgegen,
			# wobei builder.join, builder.select, builder.where und builder.wobs von interesse sind.
			# mehrere Schluessel bedeuten, dass die Values _alle_ zutreffen muessen, wobei die Schluessel geodert werden.
			# Ex:
			# 1) {"givenname=", "Peter"} #=> givenname = 'Peter'
			# 2) {"givenname=", ["Peter", "Hans"]} #=> ( givenname = 'Peter' OR givenname = 'Hans' )
			# 3) {"givenname|surname=", ["Peter", "Mueller"]}
			#       #=> ( givenname = 'Peter' OR surname = 'Peter' ) AND ( givenname = 'Mueller' OR surname = 'Mueller' )
			def build builder, table
				values = Hash[ @value.collect {|value| [ builder.vid, value ] } ]
				values.each {|k, v| builder.wobs k.sym => v }
				if 1 == @cols.length
					@cols.each do |col|
						col.joins builder, table
						col = builder.column table+col.path, col.col
						builder.where *values.keys.collect {|vid| self.class::Where % [ col, vid.to_s ] }
					end
				else
					values.keys.each do |vid|
						builder.where *@cols.collect {|col|
								col.joins builder, table
								col = builder.column table+col.path, col.col
								self.class::Where % [ col, vid.to_s ]
							}
					end
				end
				self
			end
		end

		class NotInRange < Condition
			Operator = '!..'
			Where = "%s NOT BETWEEN %s AND %s"
			Expected = [Range, lambda {|val| Array === val && 2 == val.length } ]

			def initialze model, cols, val
				if Array === val && 2 == val.length
					f, l = val
					f, l = Time.parse(f), Time.parse(l)  if f.kind_of? String
					val = f..l
				end
				super model, cols, val
			end

			def build builder, table
				builder.wobs (v1 = builder.vid) => @value.begin, (v2 = builder.vid) => @value.end
				@cols.each do |col|
					col.joins builder, table
					builder.where self.class::Where % [ builder.column( table+col.path, col.col), v1, v2]
				end
				self
			end
		end
		InRange = simple_condition NotInRange, '..', "%s BETWEEN %s AND %s"

		class NotIn < Condition
			Operator = '!|='
			Where = "%s NOT IN (%s)"
			Expected = [Array]

			def build builder, table
				builder.wobs (v = builder.vid).to_sym => @value
				@cols.each do |col|
					col.joins builder, table
					builder.where self.class::Where % [ builder.column( table, col), v.to_s]
				end
				self
			end
		end

		In = simple_condition NotIn, '|=', '%s IN (%s)', [Array]
		In2 = simple_condition In, '', nil, [Array]
		NotEqual = simple_condition Condition, /\!=|<>/, "%s <> %s", [Array, String, Numeric]
		GreaterThanOrEqual = simple_condition Condition, '>=', "%s >= %s", [Array, Numeric]
		LesserThanOrEqual = simple_condition Condition, '<=', "%s <= %s", [Array, Numeric]
		class EqualJoin <Condition
			Operator = '='
			Expected = [Hash]

			def initialize *pars
				super( *pars)
				cols = {}
				@cols.each do |col|
					col_model = SmqlToAR.model_of col.last_model, col.col
					#p col_model: col_model.to_s, value: @value
					cols[col] = [col_model] + ConditionTypes.try_parse( col_model, @value)
				end
				@cols = cols
			end

			def verify_column col
				refl = SmqlToAR.model_of col.last_model, col.col
				#p refl: refl, model: @model.name, col: col, :reflections => @model.reflections.keys
				raise NonExistingRelationError.new( %w[Relation], col)  unless refl
			end

			def build builder, table
				@cols.each do |col, sub|
					t = table + col.path + [col.col]
					#p sub: sub
					p col: col, joins: col.joins
					col.joins.each {|j, m| builder.join table+j, m }
					builder.join t, SmqlToAR.model_of( col.last_model, col.col)
					sub[1..-1].each {|one| one.build builder, t }
				end
				self
			end
		end
		Equal = simple_condition Condition, '=', "%s = %s", [Array, String, Numeric]
		Equal2 = simple_condition Equal, '', "%s = %s", [String, Numeric]
		GreaterThan = simple_condition Condition, '>', "%s > %s", [Array, Numeric]
		LesserThan = simple_condition Condition, '<', "%s < %s", [Array, Numeric]
		NotIlike = simple_condition Condition, '!~', "%s NOT ILIKE %s", [Array, String]
		Ilike = simple_condition Condition, '~', "%s ILIKE %s", [Array, String]

		####### No Operator #######
		Join = simple_condition EqualJoin, '', nil, [Hash]
		InRange2 = simple_condition InRange, '', nil, [Range]
		class Select < Condition
			Operator = ''
			Expected = [nil]

			def verify_column col
				raise NonExistingSelectableError.new( col)  unless col.exist_in? or SmqlToAR.model_of( col.last_model, col.col)
			end

			def build builder, table
				@cols.each do |col|
					if col.exist_in?
						col.joins builder, table
						builder.select table+col.to_a
					else
						col.joins {|j, m| builder.includes table+j }
						builder.includes table+col.to_a
					end
				end
				self
			end
		end

		class Functions < Condition
			Operator = ':'
			Expected = [String, Array, Hash, Numeric, nil]

			class Function
				Name = nil
				Expected = []
				attr_reader :model, :func, :args

				def self.try_parse model, func, args
					SmqlToAR.logger.info( { try_parse: [func,args]}.inspect)
					self.new model, func, args  if self::Name === func and self::Expected.any? {|e| e === args }
				end

				def initialize model, func, args
					@model, @func, @args = model, func, args
				end
			end

			class Order < Function
				Name = :order
				Expected = [String, Array, Hash, nil]

				def initialize model, func, args
					SmqlToAR.logger.info( {args: args}.inspect)
					args = case args
						when String then [args]
						when Array, Hash then args.to_a
						when nil then nil
						else raise 'Oops'
						end
					SmqlToAR.logger.info( {args: args}.inspect)
					args.andand.collect! do |o|
						o = Array.wrap o
						col = Column.new model, o.first
						o = 'desc' == o.last.to_s.downcase ? :DESC : :ASC
						raise NonExistingColumnError.new( [:Column], col)  unless col.exist_in?
						[col, o]
					end
					SmqlToAR.logger.info( {args: args}.inspect)
					super model, func, args
				end

				def build builder, table
					return  if @args.blank?
					@args.each do |o|
						col, o = o
						col.joins builder, table
						t = table + col.path
						raise OnlyOrderOnBaseError.new( t)  unless 1 == t.length
						builder.order t, col.col, o
					end
				end
			end

			def self.new model, col, val
				SmqlToAR.logger.info( { function: col.first.to_sym }.inspect)
				r = nil
				constants.each do |c|
					next  if [:Function, :Where, :Expected, :Operator].include? c
					c = const_get c
					next  if Function === c or not c.respond_to?( :try_parse)
					SmqlToAR.logger.info( {f: c}.inspect)
					r = c.try_parse model, col.first.to_sym, val
					SmqlToAR.logger.info( {r: r}.inspect)
					break  if r
				end
				r
			end
		end
	end
end