module Symphonia
  module QueryColumns
    class GenericColumn

      attr_reader :name, :query, :model, :includes, :preload, :joins
      attr_writer :sort_column_name, :sort_definition
      attr_accessor :sort, :header, :default

      def initialize(name, klass = nil, options={})
        ::ActiveSupport::Deprecation.warn 'Maybe this class is over...'
        @name = name
        if klass.is_a? Symphonia::Query
          @query = klass
          @model = @query.model
        elsif klass < ActiveRecord::Base
          @model = klass
        else # default fallback
          @model = ActiveRecord::Base
        end
        @options = options

        # @sort_options = @options.delete(:sort_options) || {}
        self.header = @options.delete(:header).nil?
        self.sort = @options.delete(:sort).nil?

        @includes = Array(options.delete(:includes)) || []
        @preload = Array(options.delete(:preload)) || []
        @joins = Array(options.delete(:joins)) || []
      end

      def summarize?
        false
      end

      def header?
        !(@header === false)
      end

      def sort?
        !(@sort === false)
      end

      def default?
        !!@default
      end

      def header(view)
        ::ActiveSupport::Deprecation.warn 'Header method is deprecated -> use app/helpers/symphonia/renderer_helper.rb:59'
        if @no_header || @header === false
          title
        else
          view.symphonia_query_sort_tag(self)
        end
      end

      def sort_definition
        return nil unless sort?
        @sort_definition ||= SortableTable::SortColumnCustomDefinition.new(@name, {asc: "#{sort_column_name} asc", desc: "#{sort_column_name} desc"})
      end

      def title
        ::ActiveSupport::Deprecation.warn 'method is deprecated'
        @model.human_attribute_name(@name, @options[:i18n] || {})
      end

      def sort_options
        @sort_options
      end

      def value(entity)
        entity.send(name)
      end

      def format_value(view, entity)
        if @options[:formatter].is_a?(Proc)
          @options[:formatter].call(view, entity).to_s
        else
          case @options[:with_link]
          when :entity, true
            view.link_to(value(entity).to_s, entity)
          when :value
            view.link_to(value(entity).to_s, value(entity))
          else
            value(entity).to_s
          end
        end
      end

      def sum_value(view)
        format_value(view, OpenStruct.new(name => sum))
      end

      def sum
        return nil unless summarize?
        @sum ||= query.entities.sum(name)
      end

      def css_classes
        @name.to_s
      end

      def inspect
        "#<#{self.class.name} name='#{name}' options=#{@options.inspect}>"
      end

      private

      def t(*args)
        I18n.translate(*args)
      end

      def l(*args)
        I18n.localize(*args)
      end

      def sort_column_name
        @sort_column_name.presence || [@model.table_name, @name].join('.')
      end
    end

    class TextColumn < GenericColumn

      def format_value(view, entity)
        view.format_text(super(view, entity))
      end

    end

    class NumberColumn < GenericColumn

      def summarize?
        true
      end

    end

    class PriceColumn < NumberColumn

      def format_value(view, entity)
        view.format_price(super(view, entity))
      end

    end

    class DateColumn < GenericColumn

      def format_value(view, entity)
        value(entity) && l(value(entity), format: @options[:format])
      end

    end

    class BooleanColumn < GenericColumn

      def format_value(view, entity)
        if value(entity)
          view.fa_icon('true', title: t(:true))
        end
      end

    end

  end

end