import { generateQueryString } from "@/utils/queryStringUtil";
import { apiSlice } from ".";
import URLS from "./constants";

export interface CPCompany {
  _id?: string;
  id?: string;
  companyName: string;
  website?: string;
  address?: string;
  city?: string;
  state?: string;
  country?: string;
  baseCommissionRate?: number;
  notes?: string;
  status: "Active" | "Inactive";
  company?: string;
  contactCount?: number;
  primaryContactName?: string;
  primaryContactPhone?: string;
  createdBy?: { _id: string; firstName: string; lastName?: string };
  updatedBy?: { _id: string; firstName: string; lastName?: string };
  createdAt?: string;
  updatedAt?: string;
}

export interface CPContact {
  _id?: string;
  id?: string;
  firstName: string;
  lastName?: string;
  name?: string;
  email?: string;
  phones?: { dialCode: number; number: number; isPrimary?: boolean }[];
  primaryPhone?: number;
  isPrimary?: boolean;
  cpCompany?: string | CPCompany;
  status: "Active" | "Inactive";
  company?: string;
  createdBy?: { _id?: string; id?: string; firstName: string; lastName?: string };
  createdAt?: string;
  updatedAt?: string;
}

export interface CPPayment {
  _id?: string;
  id?: string;
  cpCompany?: string;
  amountPaid: number;
  paymentDate: string;
  paymentMode?: string;
  notes?: string;
  company?: string;
  createdBy?: { _id: string; firstName: string; lastName?: string };
  createdAt?: string;
}

interface GetCPCompanyListResponse {
  data: {
    results: CPCompany[];
    page: number;
    limit: number;
    totalPages: number;
    totalResults: number;
  };
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

interface GetCPCompanyByIdResponse {
  data: CPCompany;
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

interface GetCPContactListResponse {
  data: {
    results: CPContact[];
    page: number;
    limit: number;
    totalPages: number;
    totalResults: number;
  };
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

interface GetCPPaymentListResponse {
  data: {
    results: CPPayment[];
    page: number;
    limit: number;
    totalPages: number;
    totalResults: number;
  };
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

export interface CreateCPCompanyBody {
  companyName: string;
  website?: string;
  address?: string;
  city?: string;
  state?: string;
  country?: string;
  baseCommissionRate?: number;
  notes?: string;
  primaryContacts?: unknown[];
}

type UpdateCPCompanyBody = Partial<CreateCPCompanyBody>;

export interface CPContactInput {
  firstName: string;
  lastName?: string;
  email?: string;
  phone?: { countryCode: number; number: number; isPrimary?: boolean }[];
  isPrimary?: boolean;
  status?: "Active" | "Inactive";
}

export interface CreateCPContactBody {
  cpCompany: string;
  contacts: CPContactInput[];
}

type UpdateCPContactBody = Partial<CPContactInput>;

export interface RecordCPPaymentBody {
  cpCompany: string;
  amountPaid: number;
  paymentDate: string;
  paymentMode?: string;
  notes?: string;
}

type GetCPCompanyListParams = {
  page?: number;
  limit?: number;
  search?: string;
  sortBy?: string;
  populate?: string;
  status?: string;
  companyId?: string;
  includeTimeStamps?: boolean;
};

type GetCPContactListParams = {
  page?: number;
  limit?: number;
  search?: string;
  sortBy?: string;
  populate?: string;
  cpCompany?: string;
  companyId?: string;
  status?: string;
  includeTimeStamps?: boolean;
};

type GetCPPaymentListParams = {
  page?: number;
  limit?: number;
  sortBy?: string;
  populate?: string;
  cpCompany?: string;
  companyId?: string;
};

export interface CPSaleRecord {
  id?: string;
  _id?: string;
  lead?: {
    id?: string;
    _id?: string;
    contactDetails?: {
      name?: string;
      phone?: string;
    };
  };
  project?: {
    id?: string;
    _id?: string;
    projectName?: string;
  };
  unit?: {
    id?: string;
    _id?: string;
    unitNumber?: string;
  };
  soldBy?: {
    id?: string;
    _id?: string;
    firstName?: string;
    lastName?: string;
  };
  cpContact?: {
    id?: string;
    _id?: string;
    firstName?: string;
    lastName?: string;
    cpCompany?: string;
  };
  bookingAmount?: number;
  commissionRate?: number;
  commissionAmount?: number;
  cpCompanyName?: string;
  action?: string;
  createdAt?: string;
  updatedAt?: string;
}

interface GetCPSalesResponse {
  data: {
    results: CPSaleRecord[];
    page: number;
    limit: number;
    totalPages: number;
    totalResults: number;
  };
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

type GetCPSalesParams = {
  cpCompany: string;
  companyId?: string;
  search?: string;
  sortBy?: string;
  limit?: number;
  page?: number;
  includeTimeStamps?: boolean;
};

export const channelPartnerApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    getCPCompanies: builder.query<
      GetCPCompanyListResponse,
      GetCPCompanyListParams
    >({
      query: (params) => ({
        url: `${URLS.CHANNEL_PARTNER}/company?${generateQueryString(
          params as Record<string, unknown>,
        )}`,
        method: "GET",
      }),
      providesTags: ["CPCompany"],
    }),

    getCPCompanyById: builder.query<GetCPCompanyByIdResponse, string>({
      query: (id) => ({
        url: `${URLS.CHANNEL_PARTNER}/company/${id}`,
        method: "GET",
      }),
      providesTags: ["CPCompany"],
    }),

    createCPCompany: builder.mutation<CPCompany, CreateCPCompanyBody>({
      query: (body) => ({
        url: `${URLS.CHANNEL_PARTNER}/company`,
        method: "POST",
        body,
      }),
      invalidatesTags: (result) => (result ? ["CPCompany"] : []),
    }),

    updateCPCompany: builder.mutation<
      CPCompany,
      { id: string; body: UpdateCPCompanyBody }
    >({
      query: ({ id, body }) => ({
        url: `${URLS.CHANNEL_PARTNER}/company/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: (result, error, { id }) => [
        { type: "CPCompany", id },
        "CPCompany",
      ],
    }),

    deleteCPCompany: builder.mutation<{ success: boolean }, string>({
      query: (id) => ({
        url: `${URLS.CHANNEL_PARTNER}/company/${id}`,
        method: "DELETE",
      }),
      invalidatesTags: (_result, _error, id) => [
        { type: "CPCompany", id },
        "CPCompany",
        "CPContact",
        "CPPayment",
      ],
    }),

    bulkUpdateCPCompanyStatus: builder.mutation<
      { success: boolean },
      { ids: string[]; status: string }
    >({
      query: (body) => ({
        url: `${URLS.CHANNEL_PARTNER}/company/bulk-status`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["CPCompany"],
    }),

    bulkDeleteCPCompanies: builder.mutation<
      { success: boolean },
      { ids: string[] }
    >({
      query: (body) => ({
        url: `${URLS.CHANNEL_PARTNER}/company/bulk-delete`,
        method: "DELETE",
        body,
      }),
      invalidatesTags: ["CPCompany", "CPContact", "CPPayment"],
    }),

    getCPContacts: builder.query<
      GetCPContactListResponse,
      GetCPContactListParams
    >({
      query: (params) => ({
        url: `${URLS.CHANNEL_PARTNER}/contact?${generateQueryString(
          params as Record<string, unknown>,
        )}`,
        method: "GET",
      }),
      providesTags: ["CPContact"],
    }),

    createCPContact: builder.mutation<CPContact[], CreateCPContactBody>({
      query: (body) => ({
        url: `${URLS.CHANNEL_PARTNER}/contact`,
        method: "POST",
        body,
      }),
      invalidatesTags: ["CPContact", "CPCompany"],
    }),

    updateCPContact: builder.mutation<
      CPContact,
      { id: string; body: UpdateCPContactBody }
    >({
      query: ({ id, body }) => ({
        url: `${URLS.CHANNEL_PARTNER}/contact/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: (result, error, { id }) => [
        { type: "CPContact", id },
        "CPContact",
        "CPCompany",
      ],
    }),

    deleteCPContact: builder.mutation<{ success: boolean }, string>({
      query: (id) => ({
        url: `${URLS.CHANNEL_PARTNER}/contact/${id}`,
        method: "DELETE",
      }),
      invalidatesTags: (_result, _error, id) => [
        { type: "CPContact", id },
        "CPContact",
        "CPCompany",
      ],
    }),

    getCPPayments: builder.query<
      GetCPPaymentListResponse,
      GetCPPaymentListParams
    >({
      query: (params) => ({
        url: `${URLS.CHANNEL_PARTNER}/payment?${generateQueryString(
          params as Record<string, unknown>,
        )}`,
        method: "GET",
      }),
      providesTags: ["CPPayment"],
    }),

    recordCPPayment: builder.mutation<CPPayment, RecordCPPaymentBody>({
      query: (body) => ({
        url: `${URLS.CHANNEL_PARTNER}/payment`,
        method: "POST",
        body,
      }),
      invalidatesTags: (result) =>
        result ? ["CPPayment", "CPCompany"] : [],
    }),

    getCPSales: builder.query<GetCPSalesResponse, GetCPSalesParams>({
      query: (params) => ({
        url: `${URLS.CHANNEL_PARTNER}/sales?${generateQueryString(
          params as Record<string, unknown>,
        )}`,
        method: "GET",
      }),
      providesTags: ["CPCompany"],
    }),
  }),
  overrideExisting: false,
});

export const {
  useGetCPCompaniesQuery,
  useGetCPCompanyByIdQuery,
  useCreateCPCompanyMutation,
  useUpdateCPCompanyMutation,
  useDeleteCPCompanyMutation,
  useBulkUpdateCPCompanyStatusMutation,
  useBulkDeleteCPCompaniesMutation,
  useGetCPContactsQuery,
  useCreateCPContactMutation,
  useUpdateCPContactMutation,
  useDeleteCPContactMutation,
  useGetCPPaymentsQuery,
  useRecordCPPaymentMutation,
  useGetCPSalesQuery,
} = channelPartnerApi;