# frozen_string_literal: true

module Qismo
  module Api
    # List customer rooms
    #
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    def rooms(opt = {})
      body = post("/api/v2/customer_rooms", opt)
      CollectionObject.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

    # Get room by id
    #
    # @param room_id [Integer]
    # @return [Qismo::SingleObject]
    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.data.customer_room
    end

    # List tags inside room
    #
    # @param room_id [Integer]
    # @return [Qismo::CollectionObject]
    def room_tags(room_id)
      CollectionObject.new(get("/api/v2/room_tags/#{room_id}").data)
    end

    # Add room tag
    #
    # @param room_id [Integer]
    # @param tag_name [String]
    # @return [Qismo::SingleObject]
    def add_room_tag(room_id, tag_name)
      post("/api/v2/room_tags/#{room_id}", tag: tag_name).data
    end

    # Delete room tag
    #
    # @param room_id [Integer]
    # @param tag_id [Integer]
    # @return [TrueClass]
    def delete_room_tag(room_id, tag_id)
      delete("/api/v2/room_tags/#{room_id}/#{tag_id}")
      true
    end

    # List room additional info
    #
    # @param room_id [Integer]
    # @return [Qismo::CollectionObject]
    def room_additional_info(room_id)
      CollectionObject.new(
        get(
          "/api/v1/qiscus/room/#{room_id}/user_info",
        ).data&.extras&.user_properties,
      ) || CollectionObject.new
    end

    # Set room additional info
    #
    # @note This will replace your current room additional info
    # @param room_id [Integer]
    # @param additional_info [Array<Hash>]
    # @return [Qismo::CollectionObject]
    def set_room_additional_info(room_id, additional_info)
      CollectionObject.new(
        post(
          "/api/v1/qiscus/room/#{room_id}/user_info",
          user_properties: additional_info,
        ).data&.extras&.user_properties,
      ) || CollectionObject.new
    end

    # Update room additional info
    #
    # @param room_id [Integer]
    # @param additional_info [Array]
    # @return [Qismo::CollectionObject]
    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

    # List Whatsapp broadcast history inside room
    #
    # @param room_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    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

      CollectionObject.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

    # Assign agent to room
    #
    # @param room_id [Integer]
    # @param agent_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    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

    # Remove agent from room
    #
    # @param room_id [Integer]
    # @param agent_id [Integer]
    # @return [TrueClass]
    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

    # Resolve room
    #
    # @param room_id [Integer]
    # @param last_comment_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def resolve_room(room_id, last_comment_id, opt = {})
      body = post("/api/v1/admin/service/mark_as_resolved",
        opt.merge(room_id: room_id.to_s, last_comment_id: last_comment_id))
      body.data.service
    end

    alias_method :resolve, :resolve_room

    # Get agent that can be assigned to room
    #
    # @param source [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def allocate_agent(source, opt = {})
      body = post("/api/v1/admin/service/allocate_agent", opt.merge(source: source))
      body.data.agent
    end

    # Get agent that can be allocated to room and automatically assign them
    #
    # @param room_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    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

    # List agents that are not in room and can be assigned to room
    #
    # @param room_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    def other_agents(room_id, opt = {})
      body = get("/api/v2/admin/service/other_agents", opt.merge(room_id: room_id))
      CollectionObject.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

    # List available agents in room
    #
    # @param room_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    def available_agents(room_id, opt = {})
      body = get("/api/v2/admin/service/available_agents", opt.merge(room_id: room_id))
      CollectionObject.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

    # Get new session webhook config
    #
    # @return [Qismo::SingleObject]
    def new_session_webhook
      get("/api/v2/app/config/new_session_webhook").data.configs
    end

    # Set new session webhook
    #
    # @param url [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def set_new_session_webhook(url, opt = {})
      post("/api/v2/app/config/new_session_webhook", opt.merge(url: url)).data.configs
    end

    # Get auth webhook config
    #
    # @return [Qismo::SingleObject]
    def auth_webhook
      get("/api/v2/app/config/auth_webhook").data.configs
    end

    # Set auth webhook
    #
    # @param url [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def set_auth_webhook(url, opt = {})
      post("/api/v2/app/config/auth_webhook", opt.merge(url: url)).data.configs
    end

    # Get resolve webhook config
    #
    # @return [Qismo::SingleObject]
    def resolve_webhook
      get("/api/v1/app/webhook/mark_as_resolved").data
    end

    # Set resolve webhook
    #
    # @param url [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def set_resolve_webhook(url, opt = {})
      post("/api/v1/app/webhook/mark_as_resolved", opt.merge(url: url)).data
    end

    # List agents
    #
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    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

      CollectionObject.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

    # List agents by id
    #
    # @param ids [Array<Integer>]
    # @return [Qismo::CollectionObject]
    def agents_by_ids(ids)
      CollectionObject.new(get("/api/v1/admin/agents/get_by_ids", { "ids[]": ids }).data) || CollectionObject.new
    end

    # List agents by divisions
    #
    # @param division_ids [Array<Integer>]
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    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

      CollectionObject.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

    # Get agent by id
    #
    # @param agent_id [Integer]
    # @return [Qismo::SingleObject]
    def agent(agent_id)
      get("/api/v2/admin/agent/#{agent_id}").data.agent
    end

    # Get office hour config
    #
    # @return [Qismo::SingleObject]
    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)

      SingleObject.new(data_hash)
    end

    # List WA broadcast templates
    #
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    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

      CollectionObject.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

    # Send WA outbound message
    #
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def send_wa_outbound(opt = {})
      post("/api/v3/admin/broadcast/client", opt).data
    end

    # Upload wa broadcast file that want to be sent in broadcast
    #
    # @param file [HTTP::FormData]
    # @param template_detail_id [Integer]
    # @return [Qismo::SingleObject]
    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

    # Send wa broadcast
    #
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def send_wa_broadcast(opt = {})
      post("/api/v3/admin/broadcast/send_broadcast", opt).data.broadcast_job
    end

    # List wa broadcast jobs
    #
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    def wa_broadcast_jobs(opt = {})
      body = get("/api/v2/admin/broadcast_jobs", opt)

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

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

    # Get wa broadcast job by id
    #
    # @param broadcast_job_id [Integer]
    # @return [Qismo::SingleObject]
    def wa_broadcast_job(broadcast_job_id)
      get("/api/v2/admin/broadcast_jobs/#{broadcast_job_id}").data.broadcast_job
    end

    # List wa broadcast logs
    #
    # @param broadcast_job_id [Integer]
    # @param opt [Hash]
    # @return [Qismo::CollectionObject]
    def wa_broadcast_logs(broadcast_job_id, opt = {})
      body = get("/api/v2/admin/broadcast_logs/#{broadcast_job_id}", opt)

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

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

    # Send message as bot
    #
    # @param opt [Hash]
    # @return [TrueClass]
    def send_bot_message(opt = {})
      post("#{app_id}/bot", opt)
      true
    end

    # Enable chabot in room
    #
    # @param room_id [Integer]
    # @return [TrueClass]
    def enable_bot_in_room(room_id)
      post("/bot/#{room_id}/activate", is_active: true)
      true
    end

    # Disable chatbot in room
    #
    # @param room_id [Integer]
    # @return [TrueClass]
    def disable_bot_in_room(room_id)
      post("/bot/#{room_id}/activate", is_active: false)
      true
    end

    # Handover room from chatbot to human agent
    #
    # @param room_id [Integer]
    # @return [TrueClass]
    def handover_room_from_bot(room_id)
      post("/#{app_id}/bot/#{room_id}/hand_over")
      true
    end

    # Handover room from chatbot to human agent in specific divisions
    #
    # @param room_id [Integer]
    # @param roles [Array<Integer>]
    # @param opt [Hash]
    # @return [TrueClass]
    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

    # Initiate chat using Qiscus widget channel
    #
    # @param user_id [String]
    # @param name [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def initiate_widget_chat(user_id, name, opt = {})
      opt = opt.merge(app_id: app_id, user_id: user_id, name: name)
      post("/api/v2/qiscus/initiate_chat", opt).data.customer_room
    end

    # Send message to custom channel
    #
    # @param identifier_key [String]
    # @param user_id [String]
    # @param name [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    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

    def channels
      get("/api/v2/channels").data
    end

    # Create customchannel
    #
    # @param identifier_key [String]
    # @param name [String]
    # @param webhook_url [String]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def create_custom_channel(identifier_key, name, webhook_url, opt = {})
      opt = opt.merge(
        identifier_key: identifier_key,
        name: name,
        webhook_url: webhook_url,
      )

      opt[:is_active] = true unless opt[:is_active].nil?

      post("/api/v1/custom_channel/connect", opt.merge).data
    end

    # Update custom channel
    #
    # @param id [Integer]
    # @param opt [Hash]
    # @return [Qismo::SingleObject]
    def update_custom_channel(id, opt = {})
      channel = channels.custom_channels.find { |cc| cc.id == id }
      if channel.nil?
        raise Qismo::NotFoundError.new("Channel not found", status_code: 404, response_body: nil)
      end

      channel_hash = JSON.parse(channel.to_json, symbolize_names: true)
      new_channel_config = channel_hash.merge(opt)

      post("/api/v1/custom_channel/connect/update", new_channel_config).data
    end

    # Activate custom channel
    #
    # @param id [Integer]
    # @return [Qismo::SingleObject]
    def activate_custom_channel(id)
      update_custom_channel(id, is_active: true)
    end

    # Deactivate custom channel
    #
    # @param id [Integer]
    # @return [Qismo::SingleObject]
    def deactivate_custom_channel(id)
      update_custom_channel(id, is_active: false)
    end

    def delete_custom_channel(id)
      post("/api/v2/custom_channel/connect/#{id}/delete")
      true
    end
  end
end