require_dependency "app_manager/application_controller"
require 'kaminari'
module AppManager
  class PlansController < ApplicationController
    cache_response_for :plans
    cache_response_for :index
    cache_response_for :users
    skip_before_action :verify_authenticity_token, :only => [:active_without_plan, :burst_cache, :fail_safe_backup]

    def index
      render :json => {"features" => AppManager.configuration.plan_features || []}
    end


    def plans
      active_plan_id_or_name = nil
      shopify_plan = nil
      plan = nil
      active_charge = nil
      default_plan_id = nil
      choose_later = false
      trial_activated_at = nil
      plan_obj = AppManager::Client.new
      plans = []
      if params[:shop_domain].present? && !AppManager.configuration.plan_features.nil?
        @shop = shop_data
        if !@shop.nil?
          active_plan_id_or_name = @shop[@plan_field] rescue nil
          plans = plan_obj.get_plans(params[:shop_domain], active_plan_id_or_name)
          # render json: plans and return #use this to test plan failsafe api
          if !@field_names.nil? && @field_names.has_key?('shopify_plan') && !@field_names.nil?
            shopify_plan_field = AppManager.configuration.field_names['shopify_plan']
            shopify_plan = @shop[shopify_plan_field] rescue nil
            plan = plans && plans.any? && !active_plan_id_or_name.nil? ? (plans.find { |x| x["id"] == active_plan_id_or_name }.present? ? plans.find { |x| x["id"] == active_plan_id_or_name } : nil) : nil

            @trial_activated_field = AppManager.configuration.field_names['trial_activated_at']
            trial_activated_at = @shop[@trial_activated_field] rescue nil
            active_charge = plan_obj.get_charge(params[:shop_domain])
            if active_charge && active_charge.any? && active_charge['active_charge'].nil? && active_charge['cancelled_charge'].nil? && !trial_activated_at && !plan
              choose_later = true
            end

          end
        else
          Rollbar.error("APP MANAGER >>>>  Either model is defined wrong or config.plan_id_or_name_field is nil in initializer ===")
        end
      else
        Rollbar.error("APP MANAGER >>>>  Either params missing store_domain or config.plan_features is nil in initializer ===")
      end


      plans = plan_obj.get_plans(params[:shop_domain]) if plans && plans.blank?
      default_plan_data = plans.select { |x| x['choose_later_plan'] == true }
      if default_plan_data.any?
        if default_plan_data.select { |x| x['store_base_plan'] == true }.size > 0
          shopify_plans = plans.select { |x| x['interval'] == 'EVERY_30_DAYS' }
          shopify_plans.each do |shp|
            if shp && shp["shopify_plans"].include?(shopify_plan)
              default_plan_id = shp["id"]
              break
            end
          end
        else
          default_plan_id = default_plan_data.map { |e| e['id'] }.first if default_plan_data.any? rescue nil
        end
      end

      response = {
          'plans' => plans,
          'shopify_plan' => shopify_plan,
          'plan' => plan,
          'default_plan_id' => default_plan_id,
          'choose_later' => choose_later,
          'has_active_charge' => (((active_charge && active_charge.any? && !active_charge['active_charge'].nil?) or !trial_activated_at) ? true : false) 
      }
      render json: response
    end

    def users
      if model

        search = params[:search]
        sort = params[:sort] || AppManager.configuration.field_names['created_at']
        order = params[:order] || 'asc'
        plans = params[:plans] || nil
        plans = plans.values if !plans.nil?
        shopify_plans = params[:shopify_plans] || nil
        shopify_plans = shopify_plans.values if !shopify_plans.nil?
        items_per_page = params[:itemsPerPage] || 25
        @shopify_email = AppManager.configuration.field_names['shopify_email']
        @shopify_plan_name_field = AppManager.configuration.field_names['shopify_plan']
        if params[:search]
          data = model.where("#{@shopify_domain} LIKE :search OR #{@shopify_email} LIKE :search", search: "%#{search}%")
          data = data.where(@plan_field => plans) if !plans.nil?
          data = data.where(@shopify_plan_name_field => shopify_plans) if !shopify_plans.nil?
          data = data.page(params[:page]).per(items_per_page)
        else
          data = model
          data = data.where(@plan_field => plans) if !plans.nil?
          data = data.where(@shopify_plan_name_field => shopify_plans) if !shopify_plans.nil?
          data = data.page(params[:page]).per(items_per_page)
        end
        all_user_count = model.count
        users = {
            "current_page" => data && data.current_page ? data.current_page : 0,
            "data" => data ? data.collect { |st| @field_names.map { |key, value| [key, "#{st[value]}"] }.to_h } : [],
            "first_page_url" => "#{app_url}/api/app-manager/users?page=1",
            "from" => data && data.total_pages ? data.current_page == 1 ? 1 : ((data.current_page-1)*items_per_page)+1 : 0,
            "last_page" => data && data.total_pages ? data.total_pages : 0,
            "last_page_url" => data && data.total_pages ? "#{app_url}/api/app-manager/users?page=#{data.total_pages}" : nil,
            "links" => '',
            "next_page_url" => data && data.next_page ? "#{app_url}/api/app-manager/users?page=#{data.next_page}" : nil,
            "path" => "#{app_url}/api/app-manager/users",
            "per_page" => items_per_page,
            "prev_page_url" => data && data.prev_page ? "#{app_url}/api/app-manager/users?page=#{data.prev_page}" : nil,
            "to" => data && data.total_pages ? data.current_page == data.total_pages ? all_user_count : ((data && data.current_page ? data.current_page : 0)*data.size) : 0,
            "total" => all_user_count,
        }
        render json: users

      else
        render json: nil
      end
    end

    def active_without_plan
      if params[:shop_domain].present? && params[:plan_id].present? && model
        @shop = shop_data
        @trial_activated_field = AppManager.configuration.field_names['trial_activated_at']
        plan_obj = AppManager::Client.new
        plan_data = plan_obj.get_plan(params[:plan_id], params[:shop_domain]) rescue nil
        update_info = {@plan_field => params[:plan_id], @trial_activated_field => DateTime.now}
        if !config_trial_days.nil? && !plan_data.nil?
          trial_days = plan_data['trial_days'] || 0
          update_info[config_trial_days] = trial_days
        end
        if @shop.update(update_info)
          begin
            AppManager.clear_cache
            AppManager::EventHandler.new('charge_created', {
                "plan" => plan_data,
                "charge" => nil,
                "previous_charge" => nil,
                "choose_later" => true,
                "shopify_domain" => params[:shop_domain]
            })
          rescue Exception => e
            Rollbar.error("APP MANAGER Error in Active without plan method #{e}")
          end
          render json: {'status' => true}
        else
          render json: {'status' => false, 'error' => "#{@shop.errors.full_messages.to_sentence}"}, status: 422
        end
      else
        render json: {'status' => false, 'error' => 'Shop not found or missing shop'}, status: 422
      end
    end


    def burst_cache
      AppManager.clear_cache
      head :ok
    end


    def fail_safe_backup
      params_permit
      Thread.new do
        @fs = AppManager::FailSafe.new
        begin
            @fs.sync_app_manager
        rescue Exception => e
          Rails.logger.info "APP MANAGER >>>> LOCAL DB couldn't sync with POTAL DB #{e.inspect}"
        end

        begin
        @fs.save_api_data(params)
          rescue Exception => e
          Rails.logger.info "APP MANAGER >>>> #{e.inspect}"
          end
          AppManager.clear_cache
      end
      head :ok
    end


    private

    def params_permit
      params.permit!
    end

    def model
      @models = ActiveRecord::Base.connection.tables
      @config_table = AppManager.configuration.shopify_table_name
      @shopify_domain = AppManager.configuration.shopify_domain_field
      @plan_field = AppManager.configuration.plan_id_or_name_field
      @field_names = AppManager.configuration.field_names
      @api_version = AppManager.configuration.shopify_api_version
      if @models.include?(@config_table) && !@plan_field.nil?
        return @config_table.classify.constantize
      else
        return nil
      end
    end

    def shop_data
      if model
        return model.where(@shopify_domain => params[:shop_domain]).first rescue nil
      else
        return nil
      end
    end

    def app_url
      AppManager.configuration.app_url
    end

    def config_trial_days
      @field_names = AppManager.configuration.field_names
      if !@field_names.nil? && @field_names.has_key?('total_trial_days') && !@field_names['total_trial_days'].nil? && !@field_names['total_trial_days'].blank?
        return @field_names['total_trial_days']
      else
        return nil
      end
    end

  end
end