import ApiService from "./ApiService";

export interface FlagDropdownOption {
  id: number;
  name: string;
}

export interface GivenByOption {
  id: number;
  name: string;
}

export interface EmployeeFlagListRow {
  id: string;
  employeeId: string;
  employee: string;
  department: string;
  givenBy: string;
  actionById: number | null;
  givenByInitials: string;
  openDate: string;
  resolutionDate: string;
  flagType: string;
  status: string;
}

export interface MyFlagListParams {
  page?: number;
  limit?: number;
  search?: string;
  status?: string;
  action_by_id?: number;
  flag_id?: number;
  month?: number;
  year?: number;
}

export interface MyFlagListRow {
  id: string;
  flagType: string;
  reason: string;
  givenBy: string;
  initials: string;
  actionById: number | null;
  openDate: string;
  resolutionDate: string;
  status: string;
}

export interface MyFlagDetails {
  id: string;
  title: string;
  flagType: string;
  reason: string;
  status: string;
  givenBy: string;
  givenByRole: string;
  initials: string;
  openDate: string;
  resolutionDate: string;
}

export interface EmployeeFlagListParams {
  page: number;
  limit: number;
  search?: string;
  status?: string;
  action_by_id?: number;
  flag_id?: number;
  month?: number;
  year?: number;
}

function safeString(value: any, fallback = "-") {
  if (typeof value === "string") {
    const trimmed = value.trim();
    return trimmed.length ? trimmed : fallback;
  }
  if (typeof value === "number") return String(value);
  return fallback;
}

function makeInitials(name: string) {
  const parts = name.split(" ").filter(Boolean);
  if (parts.length === 0) return "NA";
  if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
  return `${parts[0][0]}${parts[1][0]}`.toUpperCase();
}

function normalizeRows(payload: any): {
  rows: EmployeeFlagListRow[];
  total: number;
} {
  const root = payload?.data ?? payload ?? {};

  const list =
    (Array.isArray(root?.data) && root.data) ||
    (Array.isArray(root?.rows) && root.rows) ||
    (Array.isArray(root?.items) && root.items) ||
    (Array.isArray(root?.data?.data) && root.data.data) ||
    (Array.isArray(root) && root) ||
    [];

  const total = Number(
    root?.count ??
      root?.total ??
      root?.total_count ??
      root?.meta?.total ??
      root?.pagination?.total ??
      root?.data?.count ??
      root?.data?.total ??
      list.length,
  );

  return {
    total,
    rows: list.map((item: any) => {
      const givenBy = safeString(
        `${item?.actionBy?.first_name || ""} ${item?.actionBy?.last_name || ""}`.trim(),
      );

      return {
        id: safeString(item?.id || item?.flag_history_id || item?.employee_id),
        employeeId: safeString(
          item?.employee_id || item?.employee?.id || item?.id,
        ),
        employee: safeString(
          item?.employee_name ||
            item?.employee?.name ||
            `${item?.employee?.first_name || ""} ${item?.employee?.last_name || ""}`.trim(),
        ),
        department: safeString(item?.employee?.department?.name || ""),
        givenBy,
        actionById:
          Number(item?.action_by_id || item?.action_by?.id || 0) || null,
        givenByInitials: safeString(
          item?.action_by_initials || makeInitials(givenBy),
        ),
        openDate: safeString(
          item?.open_date || item?.issued_date || item?.created_at,
          "",
        ),
        resolutionDate: safeString(item?.resolve_at, ""),
        flagType: safeString(item?.flags?.name),
        status: safeString(item?.status, "pending"),
      };
    }),
  };
}

function normalizeMyFlagListRows(payload: any): {
  rows: MyFlagListRow[];
  total: number;
} {
  const root = payload?.data ?? payload ?? {};

  const list =
    (Array.isArray(root?.data) && root.data) ||
    (Array.isArray(root?.rows) && root.rows) ||
    (Array.isArray(root?.items) && root.items) ||
    (Array.isArray(root?.data?.data) && root.data.data) ||
    (Array.isArray(root) && root) ||
    [];

  const total = Number(
    root?.count ??
      root?.total ??
      root?.total_count ??
      root?.meta?.total ??
      root?.pagination?.total ??
      root?.data?.count ??
      root?.data?.total ??
      list.length,
  );

  return {
    total,
    rows: list.map((item: any) => {
      const givenBy = safeString(
        `${item?.actionBy?.first_name || ""} ${item?.actionBy?.last_name || ""}`.trim(),
      );

      return {
        id: safeString(item?.id || item?.flag_history_id),
        flagType: safeString(
          item?.flag_name ||
            item?.flag?.name ||
            item?.flag_type ||
            item?.flagType,
        ),
        reason: safeString(item?.reason || item?.description || item?.title),
        givenBy,
        initials: safeString(item?.action_by_initials || makeInitials(givenBy)),
        actionById:
          Number(item?.action_by_id || item?.action_by?.id || 0) || null,
        openDate: safeString(
          item?.open_date || item?.issued_date || item?.created_at,
          "",
        ),
        resolutionDate: safeString(
          item?.resolve_at || item?.deadline_date || item?.updated_at,
          "",
        ),
        status: safeString(item?.status, "Pending"),
        ...item,
      };
    }),
  };
}

function normalizeMyFlagDetails(payload: any): MyFlagDetails | null {
  const root = payload?.data ?? payload ?? {};
  const item = root?.data ?? root;
  if (!item || typeof item !== "object") return null;

  const givenBy = safeString(
    `${item?.actionBy?.first_name || ""} ${item?.actionBy?.last_name || ""}`.trim(),
  );
  const flagType = safeString(item?.flags?.name, "Flag");

  return {
    id: safeString(item?.id),
    title: safeString(`${flagType} Warning`),
    flagType,
    reason: safeString(item?.reason),
    status: safeString(item?.status, "pending"),
    givenBy,
    givenByRole: safeString(
      item?.action_by_role_name ||
        item?.action_by_role ||
        item?.action_by?.role?.name,
    ),
    initials: safeString(item?.action_by_initials || makeInitials(givenBy)),
    openDate: safeString(
      item?.open_date || item?.issued_date || item?.created_at,
      "",
    ),
    resolutionDate: safeString(item?.resolve_at),
  };
}

export async function getFlagTypeDropdown() {
  const response = await ApiService.request<{
    success: boolean;
    code: number;
    message: string;
    data: FlagDropdownOption[];
  }>({
    url: "/flags/dropdown",
    method: "get",
  });

  return response?.data?.data || [];
}

export async function getGivenByDropdown(teamLeadId = 180) {
  const response = await ApiService.request<any>({
    url: "/employees",
    method: "get",
    params: {
      search: "",
      page: 1,
      limit: 100,
      // team_lead_id: teamLeadId,
    },
  });

  const payload = response?.data?.data ?? {};
  const list =
    (Array.isArray(payload?.data) && payload.data) ||
    (Array.isArray(payload?.rows) && payload.rows) ||
    (Array.isArray(payload) && payload) ||
    [];

  return list.map((item: any) => ({
    id: Number(item?.id),
    name:
      item?.name ||
      item?.full_name ||
      `${item?.first_name || ""} ${item?.last_name || ""}`.trim() ||
      "-",
  })) as GivenByOption[];
}

export async function getEmployeeFlagList(params: EmployeeFlagListParams) {
  const response = await ApiService.request<any>({
    url: "/flags/employees",
    method: "get",
    params,
  });

  return normalizeRows(response?.data);
}

export async function getMyFlagList(
  employeeId: string | number,
  params: MyFlagListParams,
) {
  const response = await ApiService.request<any>({
    url: `/flags/${employeeId}/employee-history`,
    method: "get",
    params,
  });

  return normalizeMyFlagListRows(response?.data);
}

export async function getFlagHistoryDetails(flagHistoryId: string | number) {
  const response = await ApiService.request<any>({
    url: `/flags/employee-history/${flagHistoryId}`,
    method: "get",
  });

  return normalizeMyFlagDetails(response?.data);
}

export async function markAsResolved(flagHistoryId: string | number) {
  const response = await ApiService.request<any>({
    url: `/flags/mark-as-resolved/${flagHistoryId}`,
    method: "patch",
  });

  return response;
}