import ApiService from "./ApiService";

/**
 * MIS Action types and service.
 */

export type RatingValue = string | number;
export type OverallRating = "-" | "pending" | "draft";
export type MisActionStatus = "not_started" | "pending" | "reviewed" | "draft";

export interface MisActionRow {
  id: string;
  employeeName: string;
  isFlagged: boolean;
  projectTask: RatingValue;
  technicalTask: RatingValue;
  personalTask: RatingValue;
  overallRating: OverallRating;
  status: MisActionStatus;
}

export interface MisActionFilters {
  search?: string;
  year?: string;
  month?: string;
  status?: string;
  page?: number;
  limit?: number;
}

export interface MisActionListResponse {
  success: boolean;
  code: number;
  message?: string;
  data: MisActionRow[];
}

export interface MisActionDetailsResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    employee: {
      id: number;
      first_name: string;
      last_name: string;
      department: {
        id: number;
        name: string;
      };
    };
    business_tasks: string | null;
    technical_tasks: string | null;
    personal_tasks: string | null;
    month: number;
    year: number;
    business_feedback: string | null;
    technical_feedback: string | null;
    personal_feedback: string | null;
    business_rating: number;
    technical_rating: number;
    personal_rating: number;
    average_rating: number;
    kpi_ratings: Array<{
      kpi_name: string;
      id: number;
      rating: number;
    }>;
  };
}

export interface SubmitMisActionPayload {
  month: number;
  year: number;
  business_feedback: string;
  technical_feedback: string;
  personal_feedback: string;
  business_rating: number;
  technical_rating: number;
  personal_rating: number;
  employee_id: number;
  kpi_ratings: Array<{
    month: number;
    year: number;
    department_id: number;
    kpi_id: number;
    rating: number;
  }>;
}

export interface RaiseFlagPayload {
  flag_id: number;
  resolve_at: string;
  employee_id: string;
  reason: string;
}

export interface RaiseFlagResponse {
  success: boolean;
  code: number;
  message: string;
}

/**
 * Fetch MIS Action list from API
 */
export async function getMisActionList(
  filters?: MisActionFilters,
): Promise<MisActionListResponse> {
  try {
    const params: Record<string, any> = {
      page: filters?.page || 1,
      limit: filters?.limit || 10,
    };

    if (filters?.search) params.search = filters.search;
    if (filters?.status && filters.status !== "all")
      params.status = filters.status;
    if (filters?.month) params.month = filters.month;
    if (filters?.year) params.year = filters.year;

    const response = await ApiService.request<MisActionListResponse>({
      url: "/mis/mis-action",
      method: "get",
      params,
    });

    return response.data;
  } catch (error) {
    console.error("Error fetching MIS Action list:", error);
    // Fallback to static data if API fails
    return {
      success: true,
      code: 200,
      data: [],
    };
  }
}

/**
 * Get MIS Action details for an employee
 */
export async function getMisActionDetails(
  employeeId: string,
  month: number,
  year: number,
): Promise<MisActionDetailsResponse> {
  try {
    const response = await ApiService.request<MisActionDetailsResponse>({
      url: `/mis/mis-action/${employeeId}/details`,
      method: "get",
      params: { month, year },
    });

    return response.data;
  } catch (error) {
    console.error("Error fetching MIS Action details:", error);
    throw error;
  }
}

/**
 * Submit MIS Action review
 */
export async function submitMisAction(
  payload: SubmitMisActionPayload,
): Promise<any> {
  try {
    const response = await ApiService.request({
      url: "/mis/mis-action",
      method: "post",
      data: payload,
    });

    return response.data;
  } catch (error) {
    console.error("Error submitting MIS Action:", error);
    throw error;
  }
}

/**
 * Raise flag for employee
 */
export async function raiseFlag(
  payload: RaiseFlagPayload,
): Promise<RaiseFlagResponse> {
  try {
    const response = await ApiService.request<RaiseFlagResponse>({
      url: "/flags/action-employee",
      method: "post",
      data: payload,
    });

    return response.data;
  } catch (error) {
    console.error("Error raising flag:", error);
    throw error;
  }
}