class AppsConfigExtractor

  def initialize(email, lcc_code)
    creator_id = User.find_by_email(email) ? User.find_by_email(email).id : false
    company_code = Lcc.find_by(code: lcc_code) ? Lcc.find_by(code: lcc_code).code : false

    if creator_id && company_code
      env = Rails.application.secrets.pex_host_url.split('//').last[0..2].upcase
      document_generator = Dm::DataMigration::DocumentGeneratorSchedule.new
      document_type = 'INTERNAL'

      @output = Object.new
      @LccConfigCounter = 0
      @EftConfigCounter = 0
      @PayGroupConfigCounter = 0
      @CalendarPeriodConfigCounter = 0
      @EmailDomainConfigCounter = 0
      @CustomerConfigCounter = 0
      @PayElementConfigCounter = 0
      @JWTConfigCounter = 0
      @ActiveFormConfigCounter = 0

      file = generate(env, company_code)
      file_name = "#{document_type}_#{Gcc.first.code}_#{company_code}_D#{DateTime.now.utc.strftime('%Y%m%d')}_O999"
      params_for_document = params_for_config_report(creator_id, file_name, company_code)
      document = document_generator.create_document(file, params_for_document, [], "#{file_name}.xml")

      document
    else
      puts "Please enter a valid params email address: #{creator_id}, lcc code: #{company_code}".colorize(:yellow)

      false
    end
  end

  def params_for_config_report(creator_id, document_name, company_code)
    {
        generated: true,
        document_type: Dm::DocumentType.internal,
        display_name: document_name,
        creator_id: creator_id,
        lcc_id: Lcc.where(code: company_code).last.id
    }
  end

  def generate(env, lcc_code)
    temp_file = Tempfile.new('apps_config_extract.xml')

    begin
      Gcc.find_each do |gcc|
          @output = {
            ENV: env,
            GccConfig: [
              code: gcc.code,
              description: gcc.description,
              onboarding_system: gcc.onboarding_system,
              create_fg_user: gcc.create_fg_user,
              connect_to_myhrw: gcc.connect_to_myhrw,
              enable_legal_notice: gcc.enable_legal_notice,
              legal_notice: gcc.legal_notice,
              is_locked: gcc.is_locked,
              validate_banks: gcc.validate_banks,
              cleahrsky: gcc.cleahrsky,
              contract_type: gcc.contract_type,
              direct_costing_post_processing: gcc.direct_costing_post_processing,
              worklist_enabled: gcc.worklist_enabled,
              euhreka_validation: gcc.euhreka_validation,
              enable_update_delete_form_button: gcc.enable_update_delete_form_button,
              hrx_active: gcc.hrx_active
            ],
            EmailDomainConfig: get_email_domains,
            CustomerConfig: get_customer_config,
            JWTApiKeyConfig: get_jwt_api_key,
            LccConfig: get_lccs(gcc, lcc_code),
            Summary: [
              JWTConfigCounter: @JWTConfigCounter,
              LccConfigCounter: @LccConfigCounter,
              EftConfigCounter: @EftConfigCounter,
              PayGroupConfigCounter: @PayGroupConfigCounter,
              CalendarConfigCounter: @CalendarConfigCounter,
              EmailDomainConfigCounter: @EmailDomainConfigCounter,
              CustomerConfigCounter: @CustomerConfigCounter,
              PayElementConfigCounter: @PayElementConfigCounter,
              ActiveFormConfigCounter: @ActiveFormConfigCounter
            ]
          }
        end
        temp_file << @output.to_yaml
    ensure
      temp_file.close
    end

    temp_file
  end

  def get_lccs(gcc, lcc_code)
    data = Array.new

    if lcc_code == '00000' # todo
      gcc.lccs.each do |lcc|
        data.push(params_for_lccs(lcc))
        @LccConfigCounter += 1
      end
    else
      Lcc.where(code: lcc_code).find_each do |lcc|
        data.push(params_for_lccs(lcc))
        @LccConfigCounter += 1
      end
    end

    data.push({
      LccConfigCount: @LccConfigCounter
      })

    data
  end

  def params_for_lccs(lcc)
    {
      code: lcc.code,
      description: lcc.description,
      payroll_service_id: lcc.payroll_service_id,
      payroll_service_name: lcc.payroll_service.name,
      payroll_service_description: lcc.payroll_service.description,
      payroll_service_endpoint: lcc.payroll_service.payroll_service_endpoint,
      payroll_service_ws_user: lcc.payroll_service.ws_user,
      payroll_service_ws_password: '!excluded sensitive data!', #lcc.payroll_service.password,
      third_party: lcc.third_party,
      documents_only: lcc.documents_only,
      gen_psid: lcc.gen_psid,
      internal_eft_id: lcc.internal_eft_id,
      eft_config_count: lcc.efts.count,
      EftConfig: get_efts(lcc),
      PayGroups: get_paygroup(lcc),
      PayElements: get_pay_elements(lcc),
      LocalForms: get_lcc_forms(lcc)
      }
  end

  def get_efts(lcc)
    data = Array.new
    @EftConfigCounter = 0

    lcc.efts.each do |eft|
      data.push({
          id: eft.id,
          internal_eft_id: eft.internal_eft_id,
          src_username: eft.src_username,
          trg_username: eft.trg_username,
          src_host_address: eft.src_host_address,
          trg_host_address: eft.trg_host_address,
          trg_path: eft.trg_path,
          remote_src_username: eft.remote_src_username,
          target_system: eft.target_system,
          file_type: eft.file_type,
          partner_id: eft.partner_id,
          file_prefix: eft.file_prefix,
          itfn: eft.itfn,
          rename_prefix: eft.rename_prefix,
          occurence: eft.occurence
          })

        @EftConfigCounter += 1
    end

    data.push({
      EFTConfigCount: @EftConfigCounter
      })

    data
  end

  def get_paygroup(lcc)
    data = Array.new

    lcc.pay_groups.each do |pg|
      data.push({
          code: pg.code,
          description: pg.description,
          calendar: [
            country_code: pg.active_calendar.try(:country_code),
            curr_pp_start_date: pg.active_calendar.try(:curr_pp_start_date),
            curr_pp_end_date: pg.active_calendar.try(:curr_pp_end_date),
            periods: get_calendar_periods(pg)
          ]
          })

      @PayGroupConfigCounter += 1
    end
    data.push({
      PayGroupConfigCount: @PayGroupConfigCounter
      })

    data
  end

  def get_calendar_periods(pay_group)
    data = Array.new

    if pay_group.active_calendar
      pay_group.active_calendar.pay_periods.each do |pp|
        data.push({
          pp_type: pp.pp_type,
          pc_start_date: pp.pc_start_date,
          pc_end_date: pp.pc_end_date,
          cutoff_date: pp.cutoff_date,
          manual_data_load_cutoff: pp.manual_data_load_cutoff,
          time_pay_element_data_cutoff: pp.time_pay_element_data_cutoff,
          queue_open: pp.queue_open,
          pay_start_date: pp.pay_start_date,
          pay_end_date: pp.pay_end_date,
          fico_date: pp.fico_date,
          payslip_date: pp.payslip_date,
          payment_date: pp.payment_date,
          file_date: pp.file_date,
          year: pp.year,
          number: pp.number,
          offcycle: pp.offcycle,
          ticket: pp.ticket,
          pay_calendar_id: pp.pay_calendar_id,
          task_id: pp.task_id,
          earliest_retro_date: pp.earliest_retro_date
          })

          @CalendarPeriodConfigCounter += 1
      end
      data.push({
        CalendarConfigCount: @CalendarPeriodConfigCounter
        })
    end

    data
  end

  def get_email_domains
    data = Array.new

    EmailDomain.find_each do |ed|
      if ed.status.upcase == 'ACTIVE'
        data.push({
          domain: ed.domain,
          status: ed.status
          })
        @EmailDomainConfigCounter += 1
      end
    end
    data.push({
      EmailDomainConfigCount: @EmailDomainConfigCounter
      })

    data
  end

  def get_customer_config
    data = Array.new

    Conf::CustomerConfig.find_each do |cc|
      if cc.status.upcase == 'ACTIVE'
        data.push({
          trans_type: cc.trans_type,
          origin: cc.origin,
          mapping: cc.mapping,
          xsd_element: cc.xsd_element,
          status: cc.status,
          value: cc.value,
          description: cc.description,
          country: cc.country,
          })
        @CustomerConfigCounter += 1
      end
    end
    data.push({
      CustomerConfigCounter: @CustomerConfigCounter
      })

    data
  end

  def get_pay_elements(lcc)
    data = Array.new
    lcc.pay_elements.find_each do |pe|
      if pe.enabled_for_gcc
        data.push({
          code: pe.hr_id,
          description: pe.description,
          basis: pe.basis,
          type: pe.pay_element_type,
          enabled_for_gcc: pe.enabled_for_gcc
          })
         @PayElementConfigCounter += 1
       end
    end
    data.push({
      PayElementConfigCounter: @PayElementConfigCounter
      })

    data
  end

  def get_jwt_api_key
    data = Array.new
    Conf::JWTApiKey.find_each do |jt|
      data.push({
        client_id: jt.client_id,
        public_key: jt.public_key,
        secret_key: '!excluded sensitive data!' #jt.secret_key
        })
      @JWTConfigCounter += 1
    end
    data.push({
      JWTConfigCounter: @JWTConfigCounter
      })

    data
  end

  def get_lcc_forms(lcc)
    data = Array.new
    lcc.form_active_states.each do |fa|
      if fa.active
        data.push({
          code: get_form_data(fa.fcs_field_set_uuid).code,
          name: get_form_data(fa.fcs_field_set_uuid).name,
          country_code: get_form_data(fa.fcs_field_set_uuid).country_code,
          active: fa.active,
          trigger_on_hire: fa.trigger_on_hire,
          trigger_on_rehire: fa.trigger_on_rehire,
          trigger_on_transfer_old: fa.trigger_on_transfer_old,
          trigger_on_transfer_new: fa.trigger_on_transfer_new,
          trigger_on_termination: fa.trigger_on_termination,
          enabled_for_employees: fa.enabled_for_employees
          })
        @ActiveFormConfigCounter += 1
      end
    end
    data.push({
      ActiveFormConfigCounter: @ActiveFormConfigCounter
      })

    data
  end

  def get_form_data(uuid)
    Fcs::Form.where(uuid: uuid).last
  end
end

# Run the extractor (sample paramenters)
AppsConfigExtractor.new('arvinfrancis.bien@ngahr.com','HU001')