# frozen_string_literal: true

module Qismo
  module Api
    def rooms(**opt)
      body = post("/api/v2/customer_rooms", opt)
      Collection.new(
        body.data.customer_rooms,
        prev_page: body.meta&.cursor_before,
        next_page: body.meta&.cursor_after,
        prev_func: -> { rooms(opt.merge(cursor_before: body.meta&.cursor_before)) },
        next_func: -> { rooms(opt.merge(cursor_after: body.meta&.cursor_after)) },
      )
    end

    def room(room_id)
      body = get("/api/v2/customer_rooms/#{room_id}")
      if body.data.customer_room.nil?
        raise Qismo::NotFoundError.new("Room not found", status_code: 404, response_body: body.to_json)
      end

      body
    end

    def room_additional_info(room_id)
      body = get("/api/v1/qiscus/room/#{room_id}/user_info")
      body.data.extras.user_properties
    end

    def set_room_additional_info(room_id, *additional_info)
      body = post("/api/v1/qiscus/room/#{room_id}/user_info", user_properties: additional_info)
      body.data.extras.user_properties
    end

    def update_room_additional_info(room_id, *additional_info)
      old_additional_info = room_additional_info(room_id)
      new_additional_info = (additional_info + old_additional_info).uniq { |h| h.values_at("key") }
      set_room_additional_info(room_id, *new_additional_info)
    end

    def room_broadcast_history(room_id, **opt)
      body = get("/api/v2/customer_rooms/#{room_id}/broadcast_history", opt)

      next_page = body.meta.page < body.meta.total_page ? (body.meta.page + 1) : nil
      prev_page = body.meta.page > 1 ? (body.meta.page - 1) : nil

      Collection.new(
        body.data.broadcast_logs,
        next_page: next_page,
        prev_page: prev_page,
        next_func: -> { room_broadcast_history(opt.merge(page: next_page)) },
        prev_func: -> { room_broadcast_history(opt.merge(page: prev_page)) },
      )
    end

    def assign_agent(room_id, agent_id, **opt)
      body = post("/api/v1/admin/service/assign_agent", opt.merge(room_id: room_id.to_s, agent_id: agent_id))
      body.data.added_agent
    end

    def remove_agent(room_id, agent_id)
      post("/api/v1/admin/service/remove_agent", room_id: room_id.to_s, agent_id: agent_id)
      true
    end

    def resolve(room_id, last_comment_id, **opt)
      body = post("/api/v1/admin/service/mark_as_resolved",
        opt.merge(room_id: room_id, last_comment_id: last_comment_id))
      body.data.service
    end

    alias_method :resolve_room, :resolve

    def allocate_agent(source, **opt)
      body = post("/api/v1/admin/service/allocate_agent", opt.merge(source: source))
      body.data.agent
    end

    def allocate_and_assign_agent(room_id, **opt)
      body = post("/api/v1/admin/service/allocate_assign_agent", opt.merge(room_id: room_id))
      body.data.agent
    end

    def other_agents(room_id, **opt)
      body = get("/api/v2/admin/service/other_agents", opt.merge(room_id: room_id))
      Collection.new(
        body.data.agents,
        prev_page: body.meta&.cursor_before,
        next_page: body.meta&.cursor_after,
        prev_func: -> { other_agents(opt.merge(cursor_before: body.meta&.cursor_before)) },
        next_func: -> { other_agents(opt.merge(cursor_after: body.meta&.cursor_after)) },
      )
    end

    def available_agents(room_id, **opt)
      body = get("/api/v2/admin/service/available_agents", opt.merge(room_id: room_id))
      Collection.new(
        body.data.agents,
        prev_page: body.meta&.cursor_before,
        next_page: body.meta&.cursor_after,
        prev_func: -> { available_agents(opt.merge(cursor_before: body.meta&.cursor_before)) },
        next_func: -> { available_agents(opt.merge(cursor_after: body.meta&.cursor_after)) },
      )
    end

    def new_session_webhook
      get("/api/v2/app/config/new_session_webhook").data.configs
    end

    def set_new_session_webhook(url, **opt)
      post("/api/v2/app/config/new_session_webhook", opt.merge(url: url)).data.configs
    end

    def auth_webhook
      get("/api/v2/app/config/auth_webhook").data.configs
    end

    def set_auth_webhook(url, **opt)
      post("/api/v2/app/config/auth_webhook", opt.merge(url: url)).data.configs
    end

    def resolve_webhook
      get("/api/v1/app/webhook/mark_as_resolved").data
    end

    def set_resolve_webhook(url, **opt)
      post("/api/v1/app/webhook/mark_as_resolved", opt.merge(url: url)).data
    end

    def agents(**opt)
      if opt[:page].nil? || opt[:page].empty?
        opt[:page] = 1
      end

      body = get("/api/v2/admin/agents", opt)

      total_page = (body.meta.total_count.to_f / body.meta.per_page.to_f).ceil
      next_page = opt[:page] < total_page ? (opt[:page] + 1) : nil
      prev_page = opt[:page] > 1 ? (opt[:page] - 1) : nil

      Collection.new(
        body.data.agents,
        next_page: next_page,
        prev_page: prev_page,
        next_func: -> { agents(opt.merge(page: next_page)) },
        prev_func: -> { agents(opt.merge(page: prev_page)) },
      )
    end

    def agents_by_ids(*ids)
      get("/api/v1/admin/agents/get_by_ids", **{ "ids[]": ids }).data
    end

    def agents_by_divisions(*division_ids, **opt)
      body = get("/api/v2/admin/agents/by_division", opt.merge({ "division_ids[]": division_ids }))

      next_page = body.meta.page < body.meta.total_page ? (body.meta.page + 1) : nil
      prev_page = body.meta.page > 1 ? (body.meta.page - 1) : nil

      Collection.new(
        body.data,
        next_page: next_page,
        prev_page: prev_page,
        next_func: -> { agents_by_divisions(opt.merge(page: next_page)) },
        prev_func: -> { agents_by_divisions(opt.merge(page: prev_page)) },
      )
    end

    def agent(agent_id)
      get("/api/v2/admin/agent/#{agent_id}").data.agent
    end

    def office_hours
      data = get("/api/v1/admin/office_hours").data
      data_hash = data.as_json
      data_hash["is_in_office_hour"] = Util.in_office_hour?(data)

      DataObject.new(data_hash)
    end

    def wa_broadcast_templates(**opt)
      body = get("/api/v3/admin/hsm", opt)

      meta = body.meta
      next_page = meta.page < meta.total_page ? (meta.page + 1) : nil
      prev_page = meta.page > 1 ? (meta.page - 1) : nil

      Collection.new(
        body.data.hsm_templates,
        next_page: next_page,
        prev_page: prev_page,
        next_func: -> { wa_broadcast_templates(opt.merge(page: next_page)) },
        prev_func: -> { wa_broadcast_templates(opt.merge(page: prev_page)) },
      )
    end

    def send_wa_outbound(**opt)
      post("/api/v3/admin/broadcast/client", opt).data
    end

    def upload_wa_broadcast_csv(file, template_detail_id)
      raise ArgumentError, "Invalid file" unless file.is_a?(HTTP::FormData::File)

      post_upload("/api/v3/admin/broadcast/upload_csv", file: file, template_detail_id: template_detail_id)
    end

    def send_wa_broadcast(**opt)
      post("/api/v3/admin/broadcast/send_broadcast", opt).data.broadcast_job
    end

    def wa_broadcast_jobs(**opt)
      get("/api/v2/admin/broadcast_jobs", opt).data.broadcast_jobs
    end

    def wa_broadcast_job(broadcast_job_id)
      get("/api/v2/admin/broadcast_jobs/#{broadcast_job_id}").data.broadcast_job
    end

    def wa_broadcast_logs(broadcast_job_id, **opt)
      get("/api/v2/admin/broadcast_logs/#{broadcast_job_id}", opt).data.broadcast_logs
    end

    def send_bot_message(**opt)
      post("#{app_id}/bot", opt)
      true
    end

    def enable_chatbot_in_room(room_id)
      post("/bot/#{room_id}/activate", is_active: true)
      true
    end

    def disable_chatbot_in_room(room_id)
      post("/bot/#{room_id}/activate", is_active: false)
      true
    end

    def handover_room_from_bot(room_id)
      post("/#{app_id}/bot/#{room_id}/hand_over")
      true
    end

    def handover_room_from_bot_to_division(room_id, *roles, **opt)
      post("/#{app_id}/bot/#{room_id}/hand_over_to_role", opt.merge(roles: roles))
      true
    end

    def initiate_widget_chat(user_id, name, **opt)
      post("/api/v2/qiscus/initiate_chat", opt.merge(user_id: user_id, name: name)).data.customer_room
    end

    def send_message_to_custom_channel(identifier_key, user_id, name, **opt)
      post("/#{app_id}/api/v2/custom_channel/send",
        opt.merge(identifier_key: identifier_key, user_id: user_id, name: name)).data
    end
  end
end