# SmqlToAR - Base library: 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
	module Assertion
		def raise_unless cond, exception = nil, *args
			cond, exception, *args = yield. cond, exception, *args  if block_given?
			raise exception || Exception, *args  unless cond
		end

		def raise_if cond, exception = nil, *args
			cond, exception, *args = yield. cond, exception, *args  if block_given?
			raise exception || Exception, *args  if cond
		end
	end

	include ActiveSupport::Benchmarkable
	############################################################################r
	# Exceptions

	class SMQLError < Exception
		attr_reader :data
		def initialize data
			@data = data
			super data.inspect
		end
	end

	# Ein Fehler ist in einem Subquery aufgetreten.
	# Die eigentliche Exception wird in @data[:exception] hinterlegt.
	class SubSMQLError < SMQLError
		def initialize query, model, exception
			ex = {class: exception.class, message: exception.message}
			ex[:data] = exception.data  if exception.respond_to? :data
			super query: query, model: model.to_s, exception: ex
			set_backtrace exception.backtrace
		end
 	end

	class ParseError < SMQLError; end

	# Malformed ColOp
	class UnexpectedColOpError < ParseError
		def initialize model, colop, val
			super got: colop, val: val, model: model.to_s
		end
	end

	class UnexpectedError < ParseError
		def initialize model, colop, val
			super got: {colop => val}, model: model.to_s
		end
	end

	class NonExistingSelectableError < SMQLError
		def initialize got
			super got: got
		end
	end

	class NonExistingColumnError < SMQLError
		def initialize expected, got
			super expected: expected, got: got
		end
	end

	class NonExistingRelationError < SMQLError
		def initialize expected, got
			super expected: expected, got: got
		end
	end

	class ProtectedColumnError < SMQLError
		def initialize protected_column
			super protected_column: protected_column
		end
 	end

	class RootOnlyFunctionError < SMQLError
		def initialize path
			super path: path
		end
	end

	class ConColumnError < SMQLError
		def initialize expected, got
			super expected: expected, got: got
		end
	end

	class BuilderError < Exception; end

	#############################################################################

	# Model der Relation `rel` von `model`
	def self.model_of model, rel
		r = model.reflections[ rel.to_sym].andand.klass
		r.nil? && rel === :self ? model : r
	end

	# Eine Spalte in einer Tabelle, relativ zu `Column#model`.
	# Kann auch einen Pfad `Column#path` haben,  wobei `Column#col` dann
	# eine Relation von dem Model der letzten Relation von `Column#path` ist.
	class Column
		include Enumerable
		attr_reader :path, :col
		attr_accessor :model

		class Col
			include Comparable
			attr_accessor :col, :as
			def initialize col, as = nil
				if col.kind_of? Col
					@col, @as = col.col, col.as
				elsif /^(.*?)\[(.*)\]$/ =~ col.to_s
					@col, @as = $1, $2
				else
					@col, @as = col.to_s, as.to_s
					@as = nil  if @as.blank?
				end
			end

			def to_s()  @col  end
			def to_sym()  to_s.to_sym  end
			def inspect()  "#{@col}[@#{@as}]"  end
			def to_alias()  "#{@col}[#{@as}]"  end

			def == other
				other = Col.new other
				@col == other.col  &&  @as == other.as
			end

			def === other
				@col == Col.new( other).col
			end
		end

		def initialize model, *col
			@model = model
			@last_model = nil
			*@path, @col = *Array.wrap( col).
					collect {|x| x.to_s.split /[.\/]/ }.
					flatten.
					collect( &Col.method( :new)).
					reject {|x| x === :self }
		end

		def last_model
			@last_model ||= each{}
		end

		def each
			model = @model
			@path.each do |rel|
				unless rel === :self
					model = SmqlToAR.model_of model, rel
					return false  unless model
					yield rel, model
				end
			end
			model
		end

		def exist_in?
			model = last_model
			return false  unless model
			model.column_names.include? @col.to_s
		end

		def protected?
			model = @model
			each do |rel, _model|
				pr = Array.wrap model.respond_to?( :smql_protected) ? model.smql_protected : nil
				pr.include? rel.to_s
				model = _model
			end
			pr = Array.wrap model.respond_to?( :smql_protected) ? model.smql_protected : nil
			pr.include? @col.to_s
		end

		def joins builder = nil, table = nil, &exe
			pp = []
			table = Array.wrap table
			exe ||= builder ? lambda {|j, m| builder.joins table+j, m} : Array.method( :[])
			collect do |rel, model|
				pp.push rel
				exe.call pp, model
			end
	 	end

		def self?()  !@col  end
		def length() @path.length+(self.self? ? 0 : 1)  end
		def size()   @path.size+(self.self? ? 0 : 1)  end
		def to_a()   @path+(self.self? ? [] : [@col])  end
		def to_s()   to_a.join '.'  end
		def to_sym() to_s.to_sym  end
		def to_json()  to_s  end
		def inspect()  "#<Column: #{model} #{to_s}>"  end
		def relation()  self.self? ? model : SmqlToAR.model_of( last_model, @col)  end
		def allowed?()  ! self.protected?  end
		def child?()  @path.empty? and !!relation  end
	end

	attr_reader :model, :query, :conditions, :builder, :order
	attr_accessor :logger
	if defined? Rails
		class Railtie < ::Rails::Railtie
			initializer "active_record.logger" do
				SmqlToAR.logger = ::Rails.logger
			end
		end
	end
	@@logger = ::Rails.logger || begin require 'logger'; Logger.new( $stdout) end

	class <<self
		def logger=(logger)  @@logger = logger  end
		def logger()  @@logger  end
	end

	def initialize model, query, order = nil
		query = JSON.parse query  if query.kind_of? String
		@model, @query, @logger, @order = model, query, @@logger, order
		#p model: @model, query: @query
	end

	def self.models models
		models = Array.wrap models
		r = Hash.new {|h,k| h[k] = {} }
		while model = models.tap( &:uniq!).pop
			refls = model.respond_to?( :reflections) && model.reflections
			refls && refls.each do |name, refl|
				r[model.name][name] = case refl
					when ActiveRecord::Reflection::ThroughReflection then {macro: refl.macro, model: refl.klass.name, through: refl.through_reflection.name}
					when ActiveRecord::Reflection::AssociationReflection then {macro: refl.macro, model: refl.klass.name}
					else raise "Ups: #{refl.class}"
					end
				models.push refl.klass  unless r.keys.include? refl.klass.name
			end
		end
		r
	end

	def parse
		#benchmark 'SMQL parse' do
			@conditions = ConditionTypes.try_parse @model, @query
		#end
		#p conditions: @conditions
		self
	end

	def build
		#benchmark 'SMQL build query' do
			@builder = QueryBuilder.new @model
			table = @builder.base_table
			@conditions.each {|condition| condition.build builder, table }
		#end
		#p builder: @builder
		self
	end

	def ar
		@ar ||= #benchmark 'SMQL ar' do
			@builder.to_ar
		#end
	end

	def to_ar
		#benchmark 'SMQL' do
			parse
			build
			ar
		#end
	end

	def self.to_ar *params
		new( *params).to_ar
	end

	def self.reload_library
		lib_dir = File.dirname __FILE__
		fj = lambda {|*a| File.join lib_dir, *a }
		Object.send :remove_const, :SmqlToAR
		load fj[ 'smql_to_ar.rb']
		load fj[ 'smql_to_ar', 'condition_types.rb']
		load fj[ 'smql_to_ar', 'query_builder.rb']
	end

	module ActiveRecordExtensions
		def self.included base
			base.extend ClassMethods
		end

		module ClassMethods
			def smql *params
				SmqlToAR.to_ar self, *params
			end

			def smql_protected
				[]
			end
		end
	end
end

ActiveRecord::Base.send :include, SmqlToAR::ActiveRecordExtensions