require 'voruby/adql/adql'
require 'rexml/element'

module VORuby
  
  module ADQL
  	class ScalarExpression
  		def to_adqls
  			self.value
  		end
  	end
	
  	class ClosedExpr
  		def to_adqls
  			"(#{self.value.to_adqls})"
  		end
  	end
	
  	class BinaryOperator
  		def to_adqls
  			self.operator
  		end
  	end
	
  	class BinaryExpr
  		def to_adqls
  			"#{self.arg1.to_adqls} #{self.oper.to_adqls} #{self.arg2.to_adqls}"
  		end
  	end
	
  	class UnaryOperator
  		def to_adqls
  			self.operator
  		end
  	end
	
  	class UnaryExpr
  		def to_adqls
  			"#{self.oper.to_adqls}#{self.arg.to_adqls}"
  		end
  	end
	
  	class ColumnReference
  		def to_adqls
  			"#{self.table}.#{self.name}"
  		end
		
  		def to_adqlx(element_name)
  		  "<#{element_name} Name=\"#{self.name}\" Table=\"#{self.table}\" " +
                "xsi:type=\"columnReferenceType\"/>"
  		end
  	end
	
  	class Atom
  		def to_adqls
  		  lit_value = self.literal
  		  if lit_value.is_a?(StringType)
  			  "'#{lit_value.to_adqls}#{self.unit || ''}'"
  			else
  			  "#{lit_value.to_adqls}#{self.unit || ''}"
  		  end
  		end
		
  		def to_adqlx(element_name)
  		  literal_type = ''
  		  if self.literal.is_a?(ADQL::RealType)
  		    literal_type = 'realType'
  		  elsif self.literal.is_a?(ADQL::IntegerType)
              literal_type = 'integerType'
            elsif self.literal.is_a?(ADQL::StringType)
              literal_type = 'stringType'
            end
		  
  		  atom = "<#{element_name} xsi:type=\"atomType\">\n"
  		  atom << self.literal.to_adqlx(literal_type)
  		  atom << "\n</#{element_name}>\n"
		  
  		  return atom
  		end
  	end
	
  	class LiteralType
  		def to_adqls
  			self.value.to_s
  		end
		
  		def to_adqlx(literal_type)
  		  "<Literal xsi:type=\"#{literal_type}\" Value=\"#{self.value.to_s}\" />"
  		end
  	end
	
  	class SelectionOption
  		def to_adqls
  			self.option.option
  		end
  	end
	
  	class AllOrDistinct
  		def to_adqls
  			self.option
  		end
  	end
	
  	class TrigonometricFunctionName
  		def to_adqls
    	  self.value
    	end
  	end
	
  	class TrigonometricFunction
  	  def to_adqls
    	  if self.allow
    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
    		else
    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
    		end
  		end
    end
	
  	class MathFunctionName
  		def to_adqls
  			self.value
  		end
  	end
	
  	class MathFunction
  	  def to_adqls
  	    if self.allow
    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
    	  else
    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
    	  end
    	end 
    end
	
  	class AggregateFunctionName
  		def to_adqls
  			self.value
  		end
  	end

    class AggregateFunction
      def to_adqls
        if self.allow
    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
    	  else
    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
    	  end
      end
    end
	
  	class AliasSelectionItem
  		def to_adqls
  			if self.as
  				"#{self.expression.to_adqls} AS #{self.as}"
  			else
  				self.expression.to_adqls
  			end
  		end
  	end
	
    class AllSelectionItem
      def to_adqls
        '*'
      end
    
      def to_adqlx(element_name)
        "<#{element_name} xsi:type=\"allSelectionItemType\"/>"
      end
    end
	
    class Comparison
      def to_adqls
        self.value
      end
    
      def to_adqlx
        self.value
      end
    end
	
    class ArchiveTable
      def to_adqls
        if self.alias_name
          "#{self.archive}:#{self.name} #{self.alias_name}"
        else
          "#{self.archive}:#{self.name}"
        end
      end
    
      def to_adqlx
        if self.alias_name
          "<Table Name=\"#{self.name}\" Archive=\"#{self.archive}\" " +
              "Alias=\"#{self.alias_name}\" xsi:type=\"tableType\"/>"
        else
          "<Table Name=\"#{self.name}\" Archive=\"#{self.archive}\" " +
              "xsi:type=\"tableType\"/>"
        end
      end
    end
	
  	class Table
  		def to_adqls
  			if self.alias_name
  				"#{self.name} #{self.alias_name}"
  			else
  				self.name
  			end
  		end
  	end
	
  	class XMatchTableAlias
  		def to_adqls
  			self.name
  		end
  	end
	
  	class DropTable
  		def to_adqls
  			"!#{self.name}"
  		end
  	end
	
    class IntersectionSearch
      def to_adqls
        "#{self.cond1.to_adqls} AND #{self.cond2.to_adqls}"
      end
    
      def to_adqlx
        intersection_search = "<Condition xsi:type=\"intersectionSearchType\">\n"
        intersection_search << self.cond1.to_adqlx
        intersection_search << self.cond2.to_adqlx
        intersection_search << "</Condition>\n"
        return intersection_search
      end
    end
	
    class UnionSearch
      def to_adqls
        "#{self.cond1.to_adqls} OR #{self.cond2.to_adqls}"
      end
    
      def to_adqlx
        union_search = "<Condition xsi:type=\"unionSearchType\">\n"
        union_search << self.cond1.to_adqlx
        union_search << self.cond2.to_adqlx
        union_search << "</Condition>\n"
        return union_search
      end
    end
	
  	class XMatch
  		def to_adqls
  			tables = self.tables.collect{|x| x.to_adqls}.join(', ')
  			"XMATCH(#{tables}) #{nature.value} #{sigma.value}"
  		end
  	end
	
  	class LikePred
  		def to_adqls
  			"#{self.arg.to_adqls} LIKE #{self.pattern.to_adqls}"
  		end
		
  		def to_adqlx
  		  like_pred = "<Condition xsi:type=\"likePredType\">\n"
  		  like_pred << self.arg.to_adqlx('Arg') + "\n"
  		  like_pred << self.pattern.to_adqlx('Pattern')
  		  like_pred << "</Condition>\n"
		  
  		  return like_pred
  		end
  	end
	
  	class NotLikePred
  		def to_adqls
  			"#{self.arg.to_adqls} NOT LIKE #{self.pattern.to_adqls}"
  		end
  	end
	
  	class SubQuerySet
  		def to_adqls
  			self.selection.to_adqls
  		end
  	end
	
  	class ClosedSearch
  		def to_adqls
  			"(#{self.condition.to_adqls})"
  		end
  	end
	
  	class ComparisonPred
  		def to_adqls
  			"#{self.arg1.to_adqls} #{self.comparison.to_adqls} #{self.arg2.to_adqls}"
  		end
		
  		def to_adqlx
  		  comparison_pred = "<Condition xsi:type=\"comparisonPredType\" Comparison=\"#{self.comparison.to_adqlx}\">\n"
            comparison_pred << self.arg1.to_adqlx('Arg') + "\n"
            comparison_pred << self.arg2.to_adqlx('Arg')
            comparison_pred << "</Condition>\n"
            return comparison_pred
  		end
  	end
	
  	class BetweenPred
  		def to_adqls
  			"#{self.arg1.to_adqls} BETWEEN #{self.arg2.to_adqls} AND #{self.arg3.to_adqls}"
  		end
		
  		def to_adqlx
  		  between_pred = "<Condition xsi:type=\"betweenPredType\">\n"
  		  between_pred << self.arg1.to_adqlx('Arg') + "\n"
  		  between_pred << self.arg2.to_adqlx('Arg')
  		  between_pred << self.arg3.to_adqlx('Arg')
  		  between_pred << "</Condition>\n"
  		  return between_pred
  		end
  	end
	
  	class NotBetweenPred
  		def to_adqls
  			"#{self.arg1.to_adqls} NOT BETWEEN #{self.arg2.to_adqls} AND #{self.arg3.to_adqls}"
  		end
  	end
  
    class Circle
      def to_adqls
        "#{self.shape.to_adqls} #{self.system.to_adqls} #{self.ra.to_adqls} #{self.dec.to_adqls} #{self.radius.to_adqls}"
      end
    
      def to_adqlx
        circle = "xsi:type=\"reg:circleType\" unit=\"deg\">\n"
        circle << "<reg:Center>#{self.ra.value} #{self.dec.value}</reg:Center>\n"
        circle << "<reg:Radius>#{self.radius.value}</reg:Radius>\n"
        return circle
      end
    end
  
    class Box
      def to_adqls
        "#{self.shape.to_adqls} #{self.system.to_adqls} " +
        "#{self.ra.to_adqls} #{self.dec.to_adqls} " +
        "#{self.dra.to_adqls} #{self.ddec.to_adqls}"
      end
    
      def to_adqlx
        box = "xsi:type=\"reg:boxType\">\n"
        box << "<reg:Center>#{self.ra.value} #{self.dec.value}</reg:Center>\n"
        box << "<reg:Size>#{self.dra.value} #{self.ddec.value}</reg:Size>\n"
        return box
      end
    end
  
    class RegionSearch
      def to_adqls
        "Region('#{self.shape.to_adqls}')"
      end
    
      def to_adqlx
        region = "<Condition xsi:type=\"regionSearchType\" intersection=\"#{self.intersection.value}\">\n"
        region << "<Region "
      
        region << self.shape.to_adqlx
          
        region << "</Region>\n"
        region << "</Condition>\n"
        return region
      end
    end
	
  	class InverseSearch
  	  def to_adqls
  	    "NOT #{self.condition.to_adqls}"
      end
    end
	
  	class Having
  		def to_adqls
  			"HAVING #{self.condition.to_adqls}"
  		end
  	end
	
  	class GroupBy
  		def to_adqls
  			cols = self.columns.collect{|x| x.to_adqls}.join(', ')
  			"GROUP BY #{cols}"
  		end
  	end
	
    class Where
      def to_adqls
        "WHERE #{self.condition.to_adqls}" if self.condition
      end
    
      def to_adqlx
        if self.condition
          where = "<Where>\n"
          where << self.condition.to_adqlx
          where << "\n</Where>\n"
          return where
        end
      end
    end
	
  	class From
  	  def to_adqls
  	    tables = self.tables.collect{|x| x.to_adqls}.join(', ')
  	    "FROM #{tables}"
        end
      
        def to_adqlx
          from = "<From>\n"
          from << self.tables.collect{|x| x.to_adqlx}.join("\n")
          from << "\n</From>\n"
        
          return from
        end
      end
  
    class SelectionList
        def to_adqls
          self.items.collect{|x| x.to_adqls}.join(', ')
        end
      
        def to_adqlx
          selection_list = "<SelectionList>\n"
          selection_list << self.items.collect{|x| x.to_adqlx('Item')}.join("\n")
          selection_list << "\n</SelectionList>\n"
        
          return selection_list
        end
    end
  
    class SelectionLimit
      def to_adqls
        "TOP #{self.top}"
      end
    end
  
    class Into
      def to_adqls
        "INTO #{self.table_name}"
      end
    end
  
    class OrderDirection
      def to_adqls
        self.value
      end
    end
  
    class OrderOption
      def to_adqls
        self.direction.to_adqls
      end
    end
  
    class Order
      def to_adqls
        if self.order
          "#{self.expression.to_adqls} #{self.order.to_adqls}"
        else
          "#{self.expression.to_adqls}"
        end
      end
    end
  
    class OrderExpression
      def to_adqls
        items = self.items.collect{|x| x.to_adqls}.join(', ')
        "ORDER BY #{items}"
      end
    end
  
    class ConstantListSet
      def to_adqls
        self.items.collect{ |x| 
          if x.is_a?(NumberType)
            x.to_adqls
          else
            "\"#{x.to_adqls}\""
          end
        }.join(', ')
      end
    end
  
    class InclusiveSearch
      def to_adqls
        "#{self.expression.to_adqls} IN (#{self.set.to_adqls})"
      end
    end
  
    class ExclusiveSearch
      def to_adqls
        "#{self.expression.to_adqls} NOT IN (#{self.set.to_adqls})"
      end
    end
  
    class Select
      def to_adqls
        select = 'SELECT'
        select << " #{self.allow.to_adqls}" if self.allow
        select << " #{self.restrict.to_adqls}" if self.restrict
        select << " #{self.selection_list.to_adqls}"
        select << " #{self.in_to.to_adqls}" if self.in_to
        select << " #{self.from.to_adqls}" if self.from
        select << " #{self.where.to_adqls}" if self.where
        select << " #{self.group_by.to_adqls}" if self.group_by
        select << " #{self.having.to_adqls}" if self.having
        select << " #{self.order_by.to_adqls}" if self.order_by
      
        return select
      end
    
      def to_adqlx
        adqlx = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<Select xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
            "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " +
            "xmlns=\"http://www.ivoa.net/xml/ADQL/v0.9\" " +
            "xmlns:reg=\"http://www.ivoa.net/xml/STC/STCregion/v1.20\">\n"
      
  #      adqlx << " #{self.allow.to_adqlx}" if self.allow
  #      adqlx << " #{self.restrict.to_adqlx}" if self.restrict
        adqlx << " #{self.selection_list.to_adqlx}"
  #      adqlx << " #{self.in_to.to_adqlx}" if self.in_to
        adqlx << " #{self.from.to_adqlx}" if self.from
        adqlx << " #{self.where.to_adqlx}" if self.where
  #      adqlx << " #{self.group_by.to_adqlx}" if self.group_by
  #      adqlx << " #{self.having.to_adqlx}" if self.having
  #      adqlx << " #{self.order_by.to_adqlx}" if self.order_by
        adqlx << "</Select>"
      
        return adqlx
      end
    end
  
    class UserDefinedFunction
      def to_adqls
        params = ''
        if self.params and self.params.size > 0
          params = self.params.collect{|x| x.to_adqls}.join(', ')
        end
        "#{self.name}(#{params})"
      end
    end
  
    class JointTableQualifier
      def to_adqls
        self.value
      end
    end
  
    class JoinTable
      def to_adqls
        "#{self.qualifier.to_adqls} #{self.tables.to_adqls} ON #{self.condition.to_adqls}"
      end
    end
  
    class ArrayOfFromTable
      def to_adqls
        self.from_tables.collect{|x| x.to_adqls}.join(', ')
      end
    end

    class Unit
      def to_adqls
        self.unit
      end
    end
  end
  
end