# frozen_string_literal: true

require_relative '../log/loggable'
require_relative '../vle/vle_settings'
require_relative '../vle/vle_create_asset'
require_relative '../vle/vle_ingest_asset'
require_relative '../vendors/broad_sign/broad_sign_transform_schedule'
require_relative '../vendors/vistar/vistar_transform_schedule'
require_relative '../auth/auth_token_service'
require 'auth/client/request/auth_aware_request'

module SchedulePipeline
  class ProcessSchedule
    include Log::Loggable

    def initialize(in_queue, out_queue, errors, tokens = Auth::AuthTokenService.instance)
      @in_queue = in_queue
      @out_queue = out_queue
      @errors = errors
      @tokens = tokens
    end

    def start
      @in_queue.subscribe do |msg|
        msg = Models::ScheduleProcessMsg.from_hash(msg) if msg.is_a? Hash
        process_msg(msg)
      end
    end

    def process_msg(msg)
      logger.info("Process Schedule")

      vendor = msg.vendor
      schedule_transform = for_vendor(vendor)
      unless schedule_transform
        @errors.push("ProcessSchedule: Unknown vendor #{vendor}")
        return
      end

      content_map = []
      msg.vendor_schedule[:contents].each do |content|
        # TODO: optimization: first check whether the content has already been ingested into VLE
        vle_asset = create_asset(content)[:asset]
        content_map << vle_asset
        ingest_content(content, vle_asset[:meta][:presigned_url])
      end

      schedule = schedule_transform.call(vendor, msg.player, msg.vendor_schedule, content_map)
      @out_queue.push(schedule)
      true
    rescue StandardError => e
      @errors.push(e.message)
    end

  private
    def create_asset(content)
      sanitized_name = content[:name].gsub(/\s+/, '_')
      Auth::Client::Request::AuthAwareRequest.new(
        Vle::VleCreateAsset.new(
          {
            name: sanitized_name,
            file: sanitized_name,
            project_id: Vle::VleSettings.instance.target_project
          }
        ),
        @tokens
      ).call
    end

    def ingest_content(content, destination)
      Vle::VleIngestAsset.new.call(content, destination)
    end

    def for_vendor(vendor)
      vendor_map[vendor&.to_sym]
    end

    def vendor_map
      @vendor_map ||= {
        broad_sign: Vendors::BroadSign::BroadSignTransformSchedule.new,
        vistar: Vendors::Vistar::VistarTransformSchedule.new
      }
    end
  end
end