import apiGlobal from './apiGlobal';
import axios from 'axios';

// Helper function to get token from localStorage
const getFromLocalStorage = (key: string) => {
  if (!key || typeof window === 'undefined') {
    return "";
  }
  return localStorage.getItem(key);
};

export interface TrainingContent {
  _id: string;
  title?: string;
  description?: string;
  videoMedia?: string;
  documentMedia?: string;
  blogContent?: string;
  isDeleted: boolean;
  createdAt: string;
  updatedAt: string;
  videoMediaData?: MediaData;
  documentMediaData?: MediaData;
}

export interface MediaData {
  _id: string;
  fileName: string;
  fileType: string;
  isDeleted: boolean;
  createdAt: string;
  updatedAt: string;
  fileUrl: string;
  thumbnail?: string;
  thumbnailUrl?: string;
}

export interface TrainingCategory {
  _id: string;
  categoryName: string;
  media: string;
  isDeleted: boolean;
  createdAt: string;
  updatedAt: string;
  mediaData?: MediaData;
}

export interface UploadTrainingData {
  title?: string;
  description?: string;
  blogContent?: string;
  videoMedia?: File;
  documentMedia?: File;
  removeVideo?: boolean;
  removeDocument?: boolean;
}

export interface UpdateTrainingData {
  title?: string;
  description?: string;
  blogContent?: string;
  videoMedia?: File;
  documentMedia?: File;
  removeVideo?: boolean;
  removeDocument?: boolean;
}

export interface CreateCategoryData {
  categoryName: string;
  media: File;
}

export interface TrainingListResponse {
  data: TrainingContent[];
  totalCount?: number;
}

export interface CategoryListResponse {
  data: TrainingCategory[];
  totalCount: number;
}

export interface ListParams {
  skip?: number;
  limit?: number;
  title?: string;
  searchType?: 'video' | 'document' | 'blog';
  categoryName?: string;
}

class TrainingService {
  // Upload training content (video, document, or blog)
  async uploadTraining(data: UploadTrainingData): Promise<{ message: string }> {
    const formData = new FormData();
    
    if (data.title) formData.append('title', data.title);
    if (data.description) formData.append('description', data.description);
    if (data.blogContent) formData.append('blogContent', data.blogContent);
    if (data.videoMedia) formData.append('videoMedia', data.videoMedia);
    if (data.documentMedia) formData.append('documentMedia', data.documentMedia);

    const response = await apiGlobal.post('/uploadTraining', formData, {
      headers: {
        'Content-Type': 'multipart/form-data',
      },
    });

    return response.data;
  }

  // Update training content
  async updateTraining(id: string, data: UpdateTrainingData): Promise<{ message: string }> {
    const formData = new FormData();
    
    if (data.title) formData.append('title', data.title);
    if (data.description) formData.append('description', data.description);
    if (data.blogContent) formData.append('blogContent', data.blogContent);
    if (data.videoMedia) formData.append('videoMedia', data.videoMedia);
    if (data.documentMedia) formData.append('documentMedia', data.documentMedia);
    
    // Add removal flags if specified
    if (data.removeVideo) formData.append('removeVideo', 'true');
    if (data.removeDocument) formData.append('removeDocument', 'true');

    const response = await apiGlobal.put(`/updateTraining/${id}`, formData, {
      headers: {
        'Content-Type': 'multipart/form-data',
      },
    });

    return response.data;
  }

  // Get single training content by ID
  async getTrainingById(id: string): Promise<TrainingContent> {
    try {
      console.log(`Fetching training content with ID: ${id}`);
      const response = await apiGlobal.get(`/getTraining/${id}`);
      console.log('Training content response:', response.data);
      
      // Handle different response structures
      const data = response.data?.data || response.data;
      if (!data) {
        throw new Error('No training content data received from API');
      }
      
      return data;
    } catch (error) {
      console.error('Error fetching training content by ID:', error);
      throw error;
    }
  }

  // Delete training content
  async deleteTraining(id: string): Promise<{ message: string }> {
    const response = await apiGlobal.delete(`/deleteTraining/${id}`);
    return response.data;
  }

  // Legacy method - keeping for backward compatibility
  async getTrainingContent(id: string): Promise<TrainingContent> {
    return this.getTrainingById(id);
  }

  // Legacy method - keeping for backward compatibility  
  async deleteTrainingContent(id: string): Promise<{ message: string }> {
    return this.deleteTraining(id);
  }

  // Fetch all training content (User endpoint)
  async fetchAllTraining(params: ListParams = {}): Promise<TrainingListResponse> {
    try {
      // Use the user endpoint for fetching training content
      const userApiUrl = `${process.env.NEXT_PUBLIC_LIVE_API_URL}/api/v1/trainingVideo`;
      const response = await axios.get(`${userApiUrl}/fetchAllTraining`, { 
        params,
        headers: {
          authorization: getFromLocalStorage('token')
        }
      });
      return response.data;
    } catch (error) {
      console.error('Error fetching training content:', error);
      throw error;
    }
  }

  // Create training category
  async createTrainingCategory(data: CreateCategoryData): Promise<{ message: string }> {
    const formData = new FormData();
    formData.append('categoryName', data.categoryName);
    formData.append('media', data.media);

    const response = await apiGlobal.post('/createTrainingVideoCategory', formData, {
      headers: {
        'Content-Type': 'multipart/form-data',
      },
    });

    return response.data;
  }

  // Fetch all training categories
  async fetchAllTrainingCategories(params: ListParams = {}): Promise<CategoryListResponse> {
    try {
      const response = await apiGlobal.get('/fetchAllTrainingCategory', { params });
      return response.data;
    } catch (error) {
      // Return empty data for now until the actual endpoint is available
      console.warn('Training categories endpoint not available, returning empty data');
      return { data: [], totalCount: 0 };
    }
  }
}

export const trainingService = new TrainingService();
export default trainingService;