import { API_BASE_URL } from '@/config';
import axios from 'axios';
import apiClient from '@/lib/api/axios-instance';
import { createHeaders } from '@/lib/api';
import {
  Leave,
  LeaveCreateRequest,
  LeaveUpdateRequest,
  LeaveStatusUpdateRequest,
  LeaveBalance
} from '@/types';

class LeaveApi {
  private baseUrl = `/api/Leave`;

  async getAll(): Promise<Leave[]> {
    try {
      console.log('LeaveApi: Fetching all leave records from', this.baseUrl);

      const response = await apiClient.get(this.baseUrl, {
        headers: createHeaders(true),
        withCredentials: false
      });

      if (!response.data) {
        console.warn('LeaveApi: No data in response');
        return [];
      }

      if (!Array.isArray(response.data)) {
        console.warn('LeaveApi: Response is not an array', response.data);
        return [];
      }

      console.log(`LeaveApi: Successfully fetched ${response.data.length} leave records`);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error('LeaveApi: Axios error fetching leave records:', error.message);

        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response headers:', error.response.headers);
          console.error('LeaveApi: Response data:', error.response.data);
        } else if (error.request) {
          console.error('LeaveApi: No response received from server');
        } else {
          console.error('LeaveApi: Error setting up request:', error.message);
        }

        if (error.message.includes('Network Error') || error.message.includes('CORS')) {
          console.error('LeaveApi: Possible CORS issue - check server CORS configuration');
        }
      } else {
        console.error('LeaveApi: Unknown error fetching leave records:', error);
      }
      return [];
    }
  }

  async getById(id: number): Promise<Leave | null> {
    try {
      console.log(`LeaveApi: Fetching leave record with ID ${id}`);
      const response = await apiClient.get(`${this.baseUrl}/${id}`);

      console.log(`LeaveApi: Successfully fetched leave record with ID ${id}`);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Error fetching leave record ${id}:`, error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
        }
      } else {
        console.error(`LeaveApi: Unknown error fetching leave record ${id}:`, error);
      }
      return null;
    }
  }

  async getByEmployeeId(employeeId: number): Promise<Leave[]> {
    try {
      console.log(`LeaveApi: Fetching leaves for employee ${employeeId}`);
      const response = await apiClient.get(`${this.baseUrl}/employee/${employeeId}`);

      console.log(`LeaveApi: Successfully fetched ${response.data?.length || 0} leaves for employee ${employeeId}`);
      return response.data || [];
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Error fetching leaves for employee ${employeeId}:`, error.message);

        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response headers:', error.response.headers);
          console.error('LeaveApi: Response data:', error.response.data);
        } else if (error.request) {
          console.error('LeaveApi: No response received from server');
        } else {
          console.error('LeaveApi: Error setting up request:', error.message);
        }

        if (error.message.includes('Network Error') || error.message.includes('CORS')) {
          console.error('LeaveApi: Possible CORS issue - check server CORS configuration');
        }
      } else {
        console.error(`LeaveApi: Unknown error fetching leaves for employee ${employeeId}:`, error);
      }
      return [];
    }
  }

  async getByDateRange(startDate: string, endDate: string): Promise<Leave[]> {
    try {
      const response = await apiClient.get(`${this.baseUrl}/range?startDate=${startDate}&endDate=${endDate}`);
      return response.data || [];
    } catch (error) {
      console.error(`Error fetching leaves for date range ${startDate} to ${endDate}:`, error);
      return [];
    }
  }

  async getPendingApprovals(): Promise<Leave[]> {
    try {
      const response = await apiClient.get(`${this.baseUrl}/pending`);
      return response.data || [];
    } catch (error) {
      console.error('Error fetching pending leave approvals:', error);
      return [];
    }
  }

  async getLeaveBalance(employeeId: number, year: number): Promise<LeaveBalance | null> {
    try {
      console.log(`LeaveApi: Fetching leave balance for employee ${employeeId} and year ${year}`);
      const response = await apiClient.get(`${this.baseUrl}Balance/employee/${employeeId}/year/${year}`);

      console.log(`LeaveApi: Successfully fetched leave balance for employee ${employeeId}`);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Error fetching leave balance for employee ${employeeId}:`, error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response data:', error.response.data);
        } else if (error.request) {
          console.error('LeaveApi: No response received from server');
        } else {
          console.error('LeaveApi: Error setting up request:', error.message);
        }
      } else {
        console.error(`LeaveApi: Unknown error fetching leave balance for employee ${employeeId}:`, error);
      }
      return null;
    }
  }

  async create(leave: LeaveCreateRequest): Promise<Leave | null> {
    try {
      console.log('LeaveApi: Creating new leave record', leave);

      // Ensure required fields are set according to API spec
      const leaveRequest = {
        id: leave.id || 0,
        employeeId: leave.employeeId,
        leaveMasterId: leave.leaveMasterId || 5, // Default to a common leave type if not specified
        startDate: leave.startDate,
        endDate: leave.endDate,
        reason: leave.reason,
        status: leave.status || 'Pending',
        appliedOn: leave.appliedOn || new Date().toISOString(),
        comments: leave.comments || '',
        documents: leave.documents || '',
        halfDay: leave.halfDay || false,
        halfDayPortion: leave.halfDayPortion || 'first', // Default to first half if not specified
        workingDays: leave.workingDays || 0,
        compOff: leave.compOff || false
      };

      console.log('LeaveApi: Formatted request', leaveRequest);

      const response = await apiClient.post(this.baseUrl, leaveRequest, {
        headers: createHeaders(true),
        withCredentials: false
      });

      console.log('LeaveApi: Successfully created leave record', response.data);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error('LeaveApi: Error creating leave record:', error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response data:', error.response.data);
        }
      } else {
        console.error('LeaveApi: Unknown error creating leave record:', error);
      }
      throw error;
    }
  }

  async update(id: number, leave: LeaveUpdateRequest): Promise<Leave | null> {
    try {
      console.log(`LeaveApi: Updating leave record ${id}`, leave);

      // Ensure halfDayPortion is included in the update request if halfDay is true
      const updateRequest = {
        ...leave,
        halfDayPortion: leave.halfDay ? (leave.halfDayPortion || 'first') : undefined
      };

      const response = await apiClient.put(`${this.baseUrl}/${id}`, updateRequest);

      console.log(`LeaveApi: Successfully updated leave record ${id}`, response.data);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Error updating leave record ${id}:`, error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response data:', error.response.data);
        }
      } else {
        console.error(`LeaveApi: Unknown error updating leave record ${id}:`, error);
      }
      throw error;
    }
  }

  async updateStatus(statusUpdate: LeaveStatusUpdateRequest): Promise<Leave | null> {
    try {
      console.log(`LeaveApi: Updating leave status for ID ${statusUpdate.id} to ${statusUpdate.status}`);
      // For status updates, we'll use the regular update endpoint
      const leaveToUpdate = await this.getById(statusUpdate.id);

      if (!leaveToUpdate) {
        throw new Error(`Leave record with ID ${statusUpdate.id} not found`);
      }

      const updatedLeave = {
        ...leaveToUpdate,
        status: statusUpdate.status,
        comments: statusUpdate.comments || leaveToUpdate.comments,
        approvedById: statusUpdate.approvedById || statusUpdate.approverId,
        approvedOn: new Date().toISOString()
      };

      const response = await apiClient.put(`${this.baseUrl}/${statusUpdate.id}`, updatedLeave);

      console.log('LeaveApi: Status update successful', response.data);
      return response.data;
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Axios error updating leave status for record ${statusUpdate.id}:`, error.message);

        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response headers:', error.response.headers);
          console.error('LeaveApi: Response data:', error.response.data);
        } else if (error.request) {
          console.error('LeaveApi: No response received from server');
        } else {
          console.error('LeaveApi: Error setting up request:', error.message);
        }

        if (error.message.includes('Network Error') || error.message.includes('CORS')) {
          console.error('LeaveApi: Possible CORS issue - check server CORS configuration');
        }
      } else {
        console.error(`LeaveApi: Unknown error updating leave status for record ${statusUpdate.id}:`, error);
      }
      throw error;
    }
  }

  async delete(id: number): Promise<void> {
    try {
      console.log(`LeaveApi: Deleting leave record ${id}`);
      await apiClient.delete(`${this.baseUrl}/${id}`);
      console.log(`LeaveApi: Successfully deleted leave record ${id}`);
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error(`LeaveApi: Error deleting leave record ${id}:`, error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
        }
      } else {
        console.error(`LeaveApi: Unknown error deleting leave record ${id}:`, error);
      }
      throw error;
    }
  }

  async uploadDocument(leaveId: number, file: File): Promise<string | null> {
    try {
      console.log(`LeaveApi: Uploading document for leave ${leaveId}`);
      const formData = new FormData();
      formData.append('file', file);

      const response = await apiClient.post(`${this.baseUrl}/${leaveId}/document`, formData);

      console.log(`LeaveApi: Successfully uploaded document for leave ${leaveId}`);
      return response.data.documentUrl;
    } catch (error) {
      console.error(`LeaveApi: Error uploading document for leave ${leaveId}:`, error);
      throw error;
    }
  }

  async getAllLeavesToday(): Promise<Leave[]> {
    try {
      console.log('LeaveApi: Fetching all leaves for today');
      const response = await apiClient.get(`${this.baseUrl}/GetAllLeavesToday`);

      console.log(`LeaveApi: Successfully fetched ${response.data?.length || 0} leaves for today`);
      return response.data || [];
    } catch (error) {
      if (apiClient.isAxiosError(error)) {
        console.error('LeaveApi: Error fetching leaves for today:', error.message);
        if (error.response) {
          console.error('LeaveApi: Response status:', error.response.status);
          console.error('LeaveApi: Response data:', error.response.data);
        }
      } else {
        console.error('LeaveApi: Unknown error fetching leaves for today:', error);
      }
      return [];
    }
  }
}

export const leaveApi = new LeaveApi();