src/services/timeLogApi.ts

import axios from 'axios';
import { API_BASE_URL } from '@/config';
import apiClient from '@/lib/api/axios-instance';
import { createHeaders } from '@/lib/api';

export interface TimeLog {
  id: number;
  workDate: string;
  startTime: string;
  endTime: string;
  comments: string;
  createdBy: string;
  updatedBy: string;
  createdDate: string;
  updatedDate: string;
  remainingHr: number;
  taskId: number;
  hrsSpent: number;
}

export interface TimeLogCreateRequest {
  id?: number;
  workDate: string;
  startTime: string;
  endTime: string;
  comments: string;
  createdBy: string;
  updatedBy: string;
  createdDate?: string;
  updatedDate?: string;
  remainingHr: number;
  taskId: number;
  hrsSpent: number;
}

export interface TimeLogUpdateRequest extends TimeLogCreateRequest {
  id: number;
}

export interface PaginatedResponse<T> {
  data: T[];
  pageNumber: number;
  pageSize: number;
  totalCount: number;
  totalPages: number;
}

// Helper to create a safe TimeLog object with default values for null/undefined fields
const createSafeTimeLog = (data: any): TimeLog => {
  return {
    id: data.id || 0,
    workDate: data.workDate || new Date().toISOString(),
    startTime: data.startTime || '00:00',
    endTime: data.endTime || '00:00',
    comments: data.comments || '',
    createdBy: data.createdBy || '',
    updatedBy: data.updatedBy || '',
    createdDate: data.createdDate || new Date().toISOString(),
    updatedDate: data.updatedDate || new Date().toISOString(),
    remainingHr: data.remainingHr || 0,
    taskId: data.taskId || 0,
    hrsSpent: data.hrsSpent || 0,
  };
};

class TimeLogApi {
  private baseUrl = `/api/TimeLog`;

  async getAll(): Promise<TimeLog[]> {
    try {
      console.log('TimeLogApi: Fetching all time logs from', this.baseUrl);
      const response = await apiClient.get(this.baseUrl);
      
      console.log('TimeLogApi: Response status', response.status);
      
      if (!response.data) {
        console.warn('TimeLogApi: No data in response');
        return [];
      }
      
      if (!Array.isArray(response.data)) {
        console.warn('TimeLogApi: Response is not an array', response.data);
        return [];
      }
      
      // Map each item to ensure it has all required fields
      return response.data.map(item => createSafeTimeLog(item));
    } catch (error) {
      console.error('Error fetching time logs:', error);
      // Return empty array instead of throwing to prevent UI crashes
      return [];
    }
  }

  async getById(id: number): Promise<TimeLog | null> {
    try {
      const response = await apiClient.get(`${this.baseUrl}/${id}`);
      if (response.data) {
        return createSafeTimeLog(response.data);
      }
      return null;
    } catch (error) {
      console.error(`Error fetching time log ${id}:`, error);
      return null;
    }
  }

  async getTimeLogByTaskID(taskId: number): Promise<TimeLog[]> {
    try {
      console.log(`TimeLogApi: Fetching time logs for task ${taskId}`);
      const response = await apiClient.get(`${this.baseUrl}/GetTimeLogByTaskID?taskId=${taskId}`);
      
      console.log(`TimeLogApi: Response status for task ${taskId} time logs`, response.status);
      
      if (!response.data) {
        console.warn(`TimeLogApi: No time logs found for task ${taskId}`);
        return [];
      }
      
      if (!Array.isArray(response.data)) {
        console.warn(`TimeLogApi: Response is not an array for task ${taskId}`, response.data);
        return [];
      }
      
      // Map each item to ensure it has all required fields
      return response.data.map((item: any) => createSafeTimeLog(item));
    } catch (error) {
      console.error(`Error fetching time logs for task ${taskId}:`, error);
      // Return empty array instead of throwing to prevent UI crashes
      return [];
    }
  }

  async getTimeLogByIssueID(issueId: number): Promise<TimeLog[]> {
    try {
      console.log(`TimeLogApi: Fetching time logs for issue ${issueId}`);
      const response = await apiClient.get(`${this.baseUrl}/by-issue/${issueId}`);
      
      console.log(`TimeLogApi: Response status for issue ${issueId} time logs`, response.status);
      
      if (!response.data) {
        console.warn(`TimeLogApi: No time logs found for issue ${issueId}`);
        return [];
      }
      
      if (!Array.isArray(response.data)) {
        console.warn(`TimeLogApi: Response is not an array for issue ${issueId}`, response.data);
        return [];
      }
      
      // Map each item to ensure it has all required fields
      return response.data.map((item: any) => createSafeTimeLog(item));
    } catch (error) {
      console.error(`Error fetching time logs for issue ${issueId}:`, error);
      // Return empty array instead of throwing to prevent UI crashes
      return [];
    }
  }

  async create(timeLog: TimeLogCreateRequest): Promise<TimeLog> {
    try {
      // Remove id if it's 0, undefined, or null
      const timeLogData = { ...timeLog };
      if (timeLogData.id === 0 || timeLogData.id === undefined || timeLogData.id === null) {
        delete timeLogData.id;
      }
      
      // Format the workDate if it's a string without time part
      if (timeLogData.workDate && typeof timeLogData.workDate === 'string') {
        if (!timeLogData.workDate.includes('T')) {
          timeLogData.workDate = timeLogData.workDate + 'T00:00:00.000Z';
        }
      }
      
      console.log('TimeLogApi: Creating time log with data', timeLogData);
      const response = await apiClient.post(this.baseUrl, timeLogData);
      
      console.log('TimeLogApi: Create response status', response.status);
      return createSafeTimeLog(response.data);
    } catch (error) {
      console.error('Error creating time log:', error);
      throw error;
    }
  }

  async update(id: number, timeLog: TimeLogUpdateRequest): Promise<TimeLog> {
    try {
      const timeLogData = { ...timeLog };
      
      // Format the workDate if it's a string without time part
      if (timeLogData.workDate && typeof timeLogData.workDate === 'string') {
        if (!timeLogData.workDate.includes('T')) {
          timeLogData.workDate = timeLogData.workDate + 'T00:00:00.000Z';
        }
      }
      
      console.log(`TimeLogApi: Updating time log ${id} with data`, timeLogData);
      const response = await apiClient.put(`${this.baseUrl}/${id}`, timeLogData);
      
      console.log(`TimeLogApi: Update response status for time log ${id}`, response.status);
      return createSafeTimeLog(response.data);
    } catch (error) {
      console.error(`Error updating time log ${id}:`, error);
      throw error;
    }
  }

  async delete(id: number): Promise<void> {
    try {
      console.log(`TimeLogApi: Deleting time log ${id}`);
      await apiClient.delete(`${this.baseUrl}/${id}`);
      console.log(`TimeLogApi: Time log ${id} deleted successfully`);
    } catch (error) {
      console.error(`Error deleting time log ${id}:`, error);
      throw error;
    }
  }

  async getPaginated(pageNumber: number = 1, pageSize: number = 10): Promise<PaginatedResponse<TimeLog>> {
    try {
      console.log(`TimeLogApi: Fetching paginated time logs (page ${pageNumber}, size ${pageSize})`);
      const response = await apiClient.get(`${this.baseUrl}/paginated`, {
        params: {
          pageNumber,
          pageSize
        }
      });
      
      console.log('TimeLogApi: Paginated response status', response.status);
      
      if (!response.data) {
        console.warn('TimeLogApi: No data in paginated response');
        return {
          data: [],
          pageNumber: 1,
          pageSize: pageSize,
          totalCount: 0,
          totalPages: 0
        };
      }
      
      // Map each item to ensure it has all required fields
      const safeData = response.data.data.map((item: any) => createSafeTimeLog(item));
      
      return {
        data: safeData,
        pageNumber: response.data.pageNumber,
        pageSize: response.data.pageSize,
        totalCount: response.data.totalCount,
        totalPages: response.data.totalPages
      };
    } catch (error) {
      console.error('Error fetching paginated time logs:', error);
      // Return empty paginated response instead of throwing to prevent UI crashes
      return {
        data: [],
        pageNumber: 1,
        pageSize: pageSize,
        totalCount: 0,
        totalPages: 0
      };
    }
  }
}

export const timeLogApi = new TimeLogApi();