gistfile1.rb

module CalculatorPortal::Products::Protheus
  class NewController < CalculatorPortal::Products::ApplicationController
    before_filter :is_a_customer_logged?
    before_action :load_simulator_calculator, :check_calculator, :check_step
    before_action :allow_breadcrumb, only_for: [ :environment, :environment_additional, :service, :support, :platform, :predictability,:summary ]

    include ApplicationHelper
    include CalculatorPortal::Products::DefaultProductActions

    def service
      @active_simulator_step = :service
      @actual_calculator_step = 4

      if request.post?
        if save_simulator
          update_step_at_calculator
          redirect_to_step :support
        end

        load_service_variables(Simulator)
      else
        if edit_step?
          @services_selector = Simulator::ServiceSelector.new

          services_selector_attrs = { default_services: answer_of_question_enum(question_enum:
                                     @services_selector.enum_of(:default_services)).answer }

          @services_selector.populate services_selector_attrs

          @database_selector = Simulator::DatabaseSelector.new

          database_selector_attrs = { database: answer_of_question_enum(question_enum:
                                      @database_selector.enum_of(:database)).answer }

          @database_selector.populate database_selector_attrs
        else
          @services_selector = Simulator::ServiceSelector.new(default_services: ["erp_agendador"])
          @database_selector = Simulator::DatabaseSelector.new(database: ["oracle"])
        end
        database_finder = DatabaseFinder.new
        @database = database_finder.find_by_acronym("oracle")
        update_calculator_by_step_service
      end
    end

    def predictability
      @active_simulator_step = :predictability
      @actual_calculator_step = 7

      if request.post?
        save_status = save_simulator
        if save_status
          update_step_at_calculator
          redirect_to_step :summary
        end

        load_predictability_variables(Simulator)
        update_calculator_by_step_predictability

        return if save_status
      else
        if edit_step?
          @predictability_configuration = Simulator::PredictabilityConfiguration.new

          predictability_configuration_attrs = {
              #limit_reached_choice: answer_of_question_enum(question_enum:
                                    #@predictability_configuration.enum_of(:limit_reached_choice)).answer,
              # aditional_cargo: answer_of_question_enum(question_enum:
              #                  @predictability_configuration.enum_of(:aditional_cargo)).answer,
              # days_of_cargo_control: answer_of_question_enum(question_enum:
              #                  @predictability_configuration.enum_of(:days_of_cargo_control)).answer,
              value_limit_alert: answer_of_question_enum(question_enum:
                               @predictability_configuration.enum_of(:value_limit_alert)).answer
          }

          @predictability_configuration.populate predictability_configuration_attrs
        else
          # @predictability_configuration = Simulator::PredictabilityConfiguration.new(limit_reached_choice: "alert",
          #                                                                            aditional_cargo: 0)
          @predictability_configuration = Simulator::PredictabilityConfiguration.new(limit_reached_choice: "alert", value_limit_alert: 0)
        end
      end

      render "/app/views/calculator_portal/products/shared/predictability"
    end

    def summary
      @product_name = active_calculator.product.name
      @current_uri = request.env['PATH_INFO']

      @active_simulator_step = :summary
      @actual_calculator_step = 8

      @provider = Provider.aws.first

      if request.post?
        save_status = save_simulator
        if save_status
          update_step_at_calculator
          redirect_to_step :confirmation
        end

        load_summary_variables(Simulator)
        update_calculator_by_step_summary

        generateCalculatorProducts = GenerateCalculatorProducts.new(calculator: active_calculator)
        generateCalculatorProducts.generate

        return if save_status
      else
        if edit_step?
          @modality_selector = Simulator::ModalitySelector.new

          modality_selector_attrs = {
              modality: answer_of_question_enum(question_enum:
                        @modality_selector.enum_of(:modality)).answer,
              question: answer_of_question_enum(question_enum:
                        @modality_selector.enum_of(:question)).answer,
          }

          @modality_selector.populate modality_selector_attrs
        else
          @modality_selector = Simulator::ModalitySelector.new(modality: @provider.variable_header_price.id)
        end
      end

      @price = CostRepository.new(provider: @provider)
      @cost2 = Cloudy::AWS::ProtheusCostCalculator.new(cost_repository: @price)

      finalValues = @cost2.costs(calculator: active_calculator)

      @price = define_price finalValues, active_calculator

      @totvs_name_product = define_names_totvs(active_calculator)

      render "/app/views/calculator_portal/products/shared/summary"
    end

    protected

    def step_mapper
      %w(company_profile product environment environment_additional service support platform predictability summary confirmation)
    end

    def init_environment_step
      @active_simulator_step = :environment
      @actual_calculator_step = 2
      @max_contract_possibility = 500
      @contract_connections_number = 2
      @max_of_simultaneous_connections = 1
      @variables = {identidades: "conexões", produto: "Protheus"}
    end

    def init_environment_additional_step
      @active_simulator_step = :environment_additional
      @actual_calculator_step = 3
      @max_contract_possibility = 500
      @contract_connections_number = 2
      @max_of_simultaneous_connections = 1
      @variables = {identidades: "conexões", produto: "Protheus"}
    end

    def init_support_step
      @active_simulator_step = :support
      @actual_calculator_step = 5
    end

    def init_platform_step
      @active_simulator_step = :platform
      @actual_calculator_step = 6
    end

    def init_confirmation_step
      @active_simulator_step = :confirmation
      @actual_calculator_step = 9
    end

    def cloudy_product_cost_calculator(cost_repository:)
      Cloudy::AWS::ProtheusCostCalculator.new cost_repository: cost_repository
    end

    private

    def actual_product
      @actual_product ||= ProductFinder.new.find_by_name "protheus"
    end

    def redirect_to_step(action)
      redirect_to url_for controller: :new, action: action, calculator_id: active_calculator.id
    end

    def load_service_variables(simulator)
      @services_selector = simulator.modules[:simulator_service_selector]
      @database_selector = simulator.modules[:simulator_database_selector]
    end

    def load_predictability_variables(simulator)
      @predictability_configuration = simulator.modules[:simulator_predictability_configuration]
    end

    def load_summary_variables(simulator)
      @modality_selector = simulator.modules[:simulator_modality_selector]
    end

    def update_calculator_by_step_environment
      week_hour_schemas = {}
      warm_up_schemas = {}

      @working_hours.each do |working_hour_stage|
        stage_id = working_hour_stage.first
        working_hour_stage = working_hour_stage.second

        working_hour_stage.select{|wh| ! wh.week_days.empty?}.each do |working_hour|
          has_previous_stage_calculator = false
          has_previous_stage_calculator = !working_hour.calculator.stage_calculators.where(stage_id: stage_id).empty? if working_hour.calculator.respond_to? :stage_calculators

          # Update the working_hour week days and working hour range if the
          # stage calculator already exists
          if has_previous_stage_calculator
            hours_schema = working_hour.calculator.stage_calculators.where(stage_id: stage_id).first.calculator_working_hour.hour_schema.select{|k,v| !v.empty?}
            working_hour.week_days = array_weekdays_pt_to_en hours_schema.keys
            working_hour.working_hour_range = {:min=>hours_schema.values.first.first, :max=>hours_schema.values.first.last}
          end

          week_hour_schemas[stage_id] = Cloudy::WeekHourSchema.new if !week_hour_schemas.include?(stage_id) || has_previous_stage_calculator
          warm_up_schemas[stage_id] = Cloudy::WarmUpSchema.new if !warm_up_schemas.include?(stage_id) || has_previous_stage_calculator

          if week_hour_schemas.has_key? stage_id
            working_hour.week_days.each do |day_of_week|
              range = [working_hour.working_hour_range[:min], working_hour.working_hour_range[:max]]
              warm_up = working_hour.top_hours_of_day.split ","
              warm_up = [] if warm_up.nil?

              case day_of_week
              when "sun"
                week_hour_schemas[stage_id].dom = range
                warm_up_schemas[stage_id].dom = warm_up unless warm_up.nil?
              when "mon"
                week_hour_schemas[stage_id].seg = range
                warm_up_schemas[stage_id].seg = warm_up unless warm_up.nil?
              when "tue"
                week_hour_schemas[stage_id].ter = range
                warm_up_schemas[stage_id].ter = warm_up unless warm_up.nil?
              when "wed"
                week_hour_schemas[stage_id].qua = range
                warm_up_schemas[stage_id].qua = warm_up unless warm_up.nil?
              when "thu"
                week_hour_schemas[stage_id].qui = range
                warm_up_schemas[stage_id].qui = warm_up unless warm_up.nil?
              when "fri"
                week_hour_schemas[stage_id].sex = range
                warm_up_schemas[stage_id].sex = warm_up unless warm_up.nil?
              when "sat"
                week_hour_schemas[stage_id].sab = range
                warm_up_schemas[stage_id].sab = warm_up unless warm_up.nil?
              end
            end
          end
        end
      end

      @active_calculator = calculator_repository.update(
          id: active_calculator.id,
          working_hours: week_hour_schemas,
          warm_up_hours: warm_up_schemas,
          number_of_devices: @connection_qtt.contract_connections_number,
          max_number_of_devices: @connection_qtt.max_of_simultaneous_connections
      )

      # Calculator Hardware generation
      hw_options = if active_calculator.install_type_extra && active_calculator.install_type_extra["database_size"].is_a?(Integer)
                     Cloudy::CalculatorHardwareOptions.new(ebs: active_calculator.install_type_extra["database_size"])
                   else
                     Cloudy::CalculatorHardwareOptions.new
                   end
      provider_calculator = Cloudy::AWS::ProtheusHardwareCalculator.new(
        number_of_devices: active_calculator.calculated_number_of_devices,
        database_id: active_calculator.database_id,
        services: active_calculator.services,
        custom_options: hw_options
      )
      calculator_hardware = GenerateCalculatorHardware.new(
        calculator: active_calculator,
        provider_calculator: provider_calculator
      )

      calculator_hardware.generate_hardware
    end

    def update_calculator_by_step_environment_additional
      week_hour_schemas = {}
      warm_up_schemas = {}

      @working_hours.each do |working_hour_stage|
        stage_id = working_hour_stage.first
        working_hour_stage = working_hour_stage.second

        working_hour_stage.select{|wh| ! wh.week_days.empty?}.each do |working_hour|
          has_previous_stage_calculator = false
          has_previous_stage_calculator = !working_hour.calculator.stage_calculators.where(stage_id: stage_id).empty? if working_hour.calculator.respond_to? :stage_calculators

          # Update the working_hour week days and working hour range if the
          # stage calculator already exists
          if has_previous_stage_calculator
            hours_schema = working_hour.calculator.stage_calculators.where(stage_id: stage_id).first.calculator_working_hour.hour_schema.select{|k,v| !v.empty?}
            working_hour.week_days = array_weekdays_pt_to_en hours_schema.keys
            working_hour.working_hour_range = {:min=>hours_schema.values.first.first, :max=>hours_schema.values.first.last}
          end

          week_hour_schemas[stage_id] = Cloudy::WeekHourSchema.new if !week_hour_schemas.include?(stage_id) || has_previous_stage_calculator
          warm_up_schemas[stage_id] = Cloudy::WarmUpSchema.new if !warm_up_schemas.include?(stage_id) || has_previous_stage_calculator

          if week_hour_schemas.has_key? stage_id
            working_hour.week_days.each do |day_of_week|
              range = [working_hour.working_hour_range[:min], working_hour.working_hour_range[:max]]
              warm_up = working_hour.top_hours_of_day.split ","
              warm_up = [] if warm_up.nil?

              case day_of_week
                when "sun"
                  week_hour_schemas[stage_id].dom = range
                  warm_up_schemas[stage_id].dom = warm_up unless warm_up.nil?
                when "mon"
                  week_hour_schemas[stage_id].seg = range
                  warm_up_schemas[stage_id].seg = warm_up unless warm_up.nil?
                when "tue"
                  week_hour_schemas[stage_id].ter = range
                  warm_up_schemas[stage_id].ter = warm_up unless warm_up.nil?
                when "wed"
                  week_hour_schemas[stage_id].qua = range
                  warm_up_schemas[stage_id].qua = warm_up unless warm_up.nil?
                when "thu"
                  week_hour_schemas[stage_id].qui = range
                  warm_up_schemas[stage_id].qui = warm_up unless warm_up.nil?
                when "fri"
                  week_hour_schemas[stage_id].sex = range
                  warm_up_schemas[stage_id].sex = warm_up unless warm_up.nil?
                when "sat"
                  week_hour_schemas[stage_id].sab = range
                  warm_up_schemas[stage_id].sab = warm_up unless warm_up.nil?
              end
            end
          end
        end
      end

      @active_calculator = calculator_repository.update(
          id: active_calculator.id,
          working_hours: week_hour_schemas,
          warm_up_hours: warm_up_schemas
      )

      # Calculator Hardware generation
      hw_options = if active_calculator.install_type_extra && active_calculator.install_type_extra["database_size"].is_a?(Integer)
                     Cloudy::CalculatorHardwareOptions.new(ebs: active_calculator.install_type_extra["database_size"])
                   else
                     Cloudy::CalculatorHardwareOptions.new
                   end
      provider_calculator = Cloudy::AWS::ProtheusHardwareCalculator.new(
          number_of_devices: active_calculator.calculated_number_of_devices,
          database_id: active_calculator.database_id,
          services: active_calculator.services,
          custom_options: hw_options
      )
      calculator_hardware = GenerateCalculatorHardware.new(
          calculator: active_calculator,
          provider_calculator: provider_calculator
      )

      calculator_hardware.generate_hardware
    end

    def update_calculator_by_step_service
      database = DatabaseFinder.new.find_by_acronym @database_selector.database
      @active_calculator = calculator_repository.update(id: active_calculator.id,
                                                        database_id: database.id)
      #CalculatorService.create(calculator: active_calculator,
      #                         service: Service.where(tag: "erp", product: actual_product).first)
      #CalculatorService.create(calculator: active_calculator,
      #                         service: Service.where(tag: "scheduler", product: actual_product).first)

      # Calculator Hardware generation
      hw_options = if active_calculator.install_type_extra && active_calculator.install_type_extra["database_size"].is_a?(Integer)
                     Cloudy::CalculatorHardwareOptions.new(ebs: active_calculator.install_type_extra["database_size"])
                   else
                     Cloudy::CalculatorHardwareOptions.new
                   end
      provider_calculator = Cloudy::AWS::ProtheusHardwareCalculator.new(
        number_of_devices: active_calculator.calculated_number_of_devices,
        database_id: active_calculator.database_id,
        services: active_calculator.services,
        custom_options: hw_options
      )
      calculator_hardware = GenerateCalculatorHardware.new(
        calculator: active_calculator,
        provider_calculator: provider_calculator
      )

      calculator_hardware.generate_hardware
    end

    def update_calculator_by_step_support
      @active_calculator = calculator_repository.update(id: active_calculator.id,
                                                        support_id: @support_selector.support)
      # Calculator Hardware generation
      hw_options = if active_calculator.install_type_extra && active_calculator.install_type_extra["database_size"].is_a?(Integer)
                     Cloudy::CalculatorHardwareOptions.new(ebs: active_calculator.install_type_extra["database_size"])
                   else
                     Cloudy::CalculatorHardwareOptions.new
                   end
      provider_calculator = Cloudy::AWS::ProtheusHardwareCalculator.new(
        number_of_devices: active_calculator.calculated_number_of_devices,
        database_id: active_calculator.database_id,
        services: active_calculator.services,
        custom_options: hw_options
      )
      calculator_hardware = GenerateCalculatorHardware.new(
        calculator: active_calculator,
        provider_calculator: provider_calculator
      )

      calculator_hardware.generate_hardware
    end

    def update_calculator_by_step_predictability
      # @active_calculator = calculator_repository.update(id: active_calculator.id,
      #                                                   additional_capacity: @predictability_configuration.aditional_cargo)

      @active_calculator = calculator_repository.update(id: active_calculator.id)

      # Calculator Hardware generation
      hw_options = if active_calculator.install_type_extra && active_calculator.install_type_extra["database_size"].is_a?(Integer)
                     Cloudy::CalculatorHardwareOptions.new(ebs: active_calculator.install_type_extra["database_size"])
                   else
                     Cloudy::CalculatorHardwareOptions.new
                   end
      provider_calculator = Cloudy::AWS::ProtheusHardwareCalculator.new(
        number_of_devices: active_calculator.calculated_number_of_devices,
        database_id: active_calculator.database_id,
        services: active_calculator.services,
        custom_options: hw_options
      )
      calculator_hardware = GenerateCalculatorHardware.new(
        calculator: active_calculator,
        provider_calculator: provider_calculator
      )
      calculator_hardware.generate_hardware
    end

    def update_calculator_by_step_summary
      @active_calculator = calculator_repository.update(id: active_calculator.id,
                                                        header_price_id: @modality_selector.modality)
    end

    def update_step_at_calculator
      calculator_repository.update id: active_calculator.id,
                                   step: (active_calculator.step > @actual_calculator_step) ? active_calculator.step : @actual_calculator_step+1
    end

    def answer_of_question_enum(question_enum:, stage_id: nil, order: nil)
      params = { question_enum: question_enum,
                 calculator_id: active_calculator.id,
                 customer_id: active_customer.id }

      params[:stage_id] = stage_id unless stage_id.nil?
      params[:order] = order unless order.nil?

      simulator_answer_repository.find_by_question_enum params
    end

    def all_answer_of_question_enum(question_enum:, stage_id: nil)
      params = { question_enum: question_enum,
                 calculator_id: active_calculator.id,
                 customer_id: active_customer.id }

      params[:stage_id] = stage_id unless stage_id.nil?

      simulator_answer_repository.find_all_by_question_enum params
    end

    def simulator_answer_repository
      @simualtor_answer_repository ||= SimulatorAnswerRepository.new
    end

    def edit_step?
      active_calculator.step > @actual_calculator_step
    end
  end
end