import { apiSlice } from ".";
import { generateQueryString } from "@/utils/queryStringUtil";
import URLS from "./constants";
import { CaptureLeadListResponse } from "@/types/capture-lead";

// ------------------- Types -------------------

export interface CaptureLeadAssignedUser {
  id: string;
}

export interface CaptureLeadSource {
  id: string;
}

export interface CaptureLeadTeam {
  id: string;
}

export interface CaptureLeadCategory {
  id: string;
}

export interface CaptureLeadConfiguration {
  id: string;
}

export interface CaptureLeadPropertyType {
  id: string;
}

export interface CaptureLeadLocality {
  id: string;
}

export interface CaptureLead {
  id: string;
  name: string;
  platform: string;
  interestType: "buy" | "rent" | "lease" | string;
  source: CaptureLeadSource;
  assignmentMode: "equal" | "manual" | string;
  team: CaptureLeadTeam;
  assignedTo: CaptureLeadAssignedUser[];
  buyingPreference: string;
  category: CaptureLeadCategory;
  configuration: CaptureLeadConfiguration[];
  propertyTypeBuy: CaptureLeadPropertyType[];
  preferredState: CaptureLeadSource;
  preferredCity: CaptureLeadSource;
  preferredLocalities: CaptureLeadLocality[];
  // Optional fields returned by backend for custom_form and others
  webhookUrl?: string;
  formEmbedHtml?: string;
}

export interface GetCaptureLeadsResponse {
  code: number;
  message: string;
  success: boolean;
  data: CaptureLeadListResponse;
  error?: object;
}

export interface CreateCaptureLeadRequest {
  name: string;
  platform: string;
  interestType: "buy" | "rent" | "lease" | string;
  source: string;
  assignmentMode: "equal" | "roundRobin" | "specificUser";
  team: string | null;
  assignedTo: string[] | null;
  buyingPreference: "open_to_suggestions" | "preferred_project";
  category: string;
  configuration: string[];
  propertyTypeBuy?: string[];
  preferredState?: string;
  preferredCity?: string;
  preferredLocalities?: string[];
}

export interface CreateCaptureLeadResponse {
  code: number;
  message: string;
  success: boolean;
  data: {
    webhookUrl: string;
    formEmbedHtml?: string;
    platform?: string;
    googleAdsWebhookKey?: string;
  };
}

// ------------------- Edit/Delete Types -------------------

export type AssignmentMode = "equal" | "roundRobin" | "specificUser";

export type PatchCaptureLeadBody = {
  name?: string;
  platform?: string;
  projectId?: string | null;
  isActive?: boolean;
  assignment?: {
    mode: AssignmentMode;
    teamId?: string | null;
    userIds?: string[];
  };
  interestType?: "buy" | "sell" | "rent" | "lease";
  sourceId?: string;
};

export interface PatchCaptureLeadResponse {
  code: number;
  message: string;
  success: true;
  data: any; // list-shaped CaptureLeadRow, using any to avoid circular import
}

export interface DeleteCaptureLeadResponse {
  code: number;
  message: string;
  success: true;
  data: { id: string };
}

// ------------------- Detail (Get by ID) Types -------------------

export interface GetCaptureLeadDetailResponse {
  code: number;
  message: string;
  success: boolean;
  data: any; // server returns a single integration detail object, may include webhookUrl and formEmbedHtml
}

// ------------------- API Slice -------------------

export const captureLeadApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    getCaptureLeads: builder.query<
      GetCaptureLeadsResponse,
      {
        page?: number;
        limit?: number;
        search?: string;
        platform?: string;
        interestType?: string;
        from?: string;
        to?: string;
      }
    >({
      query: (params) => ({
        url: `${URLS.CAPTURE_LEADS}?${generateQueryString(
          params as Record<string, unknown>
        )}`,
        method: "GET",
      }),
      providesTags: ["CaptureLead"],
    }),

    getCaptureLeadsKpi: builder.query<
      {
        code: number;
        message: string;
        success: boolean;
        data: {
          overview: {
            totalIntegrations: number;
            totalLeads: number;
            period: { from: string; to: string };
          };
          platformsConnected: number;
          trend: number[];
          platformTimeseries: {
            granularity: "day";
            series: Array<{
              platform: string;
              points: Array<{ x: string; y: number }>;
            }>;
          };
        };
      },
      {
        from: string;
        to: string;
        search?: string;
        platform?: string;
        project?: string;
      }
    >({
      query: (params) => ({
        url: `${URLS.CAPTURE_LEADS}/kpi?${generateQueryString(
          params as Record<string, unknown>
        )}`,
        method: "GET",
      }),
      providesTags: ["CaptureLead"], // ✅ ADD THIS
    }),

    createCaptureLead: builder.mutation<
      CreateCaptureLeadResponse,
      CreateCaptureLeadRequest
    >({
      query: (body) => ({
        url: `${URLS.CAPTURE_LEADS}`,
        method: "POST",
        body,
      }),
      invalidatesTags: ["CaptureLead"],
    }),

    getCaptureLeadById: builder.query<
      GetCaptureLeadDetailResponse,
      { id: string }
    >({
      query: ({ id }) => ({
        url: `${URLS.CAPTURE_LEADS}/${id}`,
        method: "GET",
      }),
      providesTags: (result, error, arg) => [
        { type: "CaptureLead" as const, id: arg.id },
      ],
    }),

    updateCaptureLead: builder.mutation<
      PatchCaptureLeadResponse,
      { id: string; body: PatchCaptureLeadBody }
    >({
      query: ({ id, body }) => ({
        url: `${URLS.CAPTURE_LEADS}/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["CaptureLead"],
    }),

    deleteCaptureLead: builder.mutation<
      DeleteCaptureLeadResponse,
      { id: string }
    >({
      query: ({ id }) => ({
        url: `${URLS.CAPTURE_LEADS}/${id}`,
        method: "DELETE",
      }),
      invalidatesTags: ["CaptureLead"],
    }),

    autheticateCompanyMeta: builder.query<GetCaptureLeadDetailResponse, void>({
      query: () => ({
        url: `${URLS.CAPTURE_LEADS}/auth/meta`,
        method: "GET",
      }),
    }),
  }),

  overrideExisting: false,
});

// ------------------- Hooks -------------------

export const {
  useGetCaptureLeadsQuery,
  useCreateCaptureLeadMutation,
  useUpdateCaptureLeadMutation,
  useDeleteCaptureLeadMutation,
  useGetCaptureLeadsKpiQuery,
  useGetCaptureLeadByIdQuery,
  useLazyGetCaptureLeadByIdQuery,
  useAutheticateCompanyMetaQuery,
} = captureLeadApi;