import ApiService from "./ApiService";

/**
 * My MIS types and service.
 */

export type RatingValue = string | number;
export type OverallRating = "-" | "pending" | "draft" | { stars: number };

export interface MyMisRow {
  id: number | null;
  month: string;
  year: number;
  status: string | null;
  business_rating: number;
  technical_rating: number;
  personal_rating: number;
  average_rating: number;
  projectTask?: RatingValue; // For backward compatibility
  technicalTask?: RatingValue; // For backward compatibility
  personalTask?: RatingValue; // For backward compatibility
  overallRating?: any; // For backward compatibility
  action?: "add" | "view"; // For backward compatibility
}

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

export interface MyMisListResponse {
  success: boolean;
  code: number;
  message?: string;
  data: {
    count: number;
    data: MyMisRow[];
  };
}

export interface MyMisDetailsResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    business_tasks: string | null;
    technical_tasks: string | null;
    personal_tasks: string | null;
    month: string;
    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;
    flag?: {
      id: number;
      employee_id: number;
      company_id: number;
      flag_id: number;
      action_by_id: number;
      reason: string;
      resolve_at: string;
      status: string;
      flag_name: string;
      flag_status: number;
      created_at: string;
      updated_at: string;
    };
    feedback_details?: {
      business_feedback: string;
      technical_feedback: string;
      personal_feedback: string;
      business_rating: number;
      technical_rating: number;
      personal_rating: number;
      average_rating: number;
      created_at: string;
      updated_at: string;
    };
  };
}

export interface CreateUpdateMisPayload {
  id?: number; // Send only in edit flow
  month: number;
  year: number;
  business_tasks: string;
  technical_tasks: string;
  personal_tasks: string;
  status: "draft" | "pending";
}

export interface CreateUpdateMisResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    id: number;
    month: number;
    year: number;
    business_tasks: string;
    technical_tasks: string;
    personal_tasks: string;
    status: string;
    employee_id: number;
    company_id: number;
    created_at: string;
    updated_at: string;
  };
}

/**
 * Transform API response to match UI expectations
 */
function transformMyMisData(apiData: MyMisRow[]): MyMisRow[] {
  return apiData.map((item) => ({
    ...item,
    month: item.month,
    year: item.year,
    projectTask: item.business_rating || "0",
    technicalTask: item.technical_rating || "0",
    personalTask: item.personal_rating || "0",
    overallRating: ["pending", "draft", null].includes(item.status || "")
      ? item.status
      : item.average_rating,
    action: item.id ? "view" : ("add" as "add" | "view"),
  }));
}

/**
 * Fetch My MIS list from API
 */
export async function getMyMisList(
  filters?: MyMisFilters,
): Promise<{ success: boolean; data: MyMisRow[]; message?: string }> {
  try {
    const params: Record<string, any> = {
      page: filters?.page || 1,
      limit: filters?.limit || 10,
    };

    if (filters?.search) params.search = filters.search;
    if (filters?.month) params.month = filters.month;
    if (filters?.year) params.year = filters.year;

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

    if (response.data.success) {
      return {
        success: true,
        data: transformMyMisData(response.data.data.data),
      };
    } else {
      return {
        success: false,
        data: [],
        message: response.data.message,
      };
    }
  } catch (error) {
    console.error("Error fetching My MIS list:", error);
    // Fallback to static data if API fails
    return {
      success: true,
      data: [],
    };
  }
}

/**
 * Get My MIS details for a specific month/year
 */
export async function getMyMisDetails(
  employeeId: string,
  month: number,
  year: number,
): Promise<MyMisDetailsResponse> {
  try {
    const response = await ApiService.request<MyMisDetailsResponse>({
      url: `/mis/my-mis/${employeeId}/details`,
      method: "get",
      params: { month, year },
    });

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

/**
 * Create or update MIS report
 */
export async function createUpdateMisReport(
  payload: CreateUpdateMisPayload,
): Promise<CreateUpdateMisResponse> {
  try {
    const response = await ApiService.request<CreateUpdateMisResponse>({
      url: "/mis/my-mis",
      method: "post",
      data: payload,
    });

    return response.data;
  } catch (error) {
    console.error("Error creating/updating MIS report:", error);
    throw error;
  }
}