import api from './axiosInstance.api';

import type {
    User,
    LoginRequest,
    LoginResponse,
    SignupOrganizationRequest,
    SignupTrainerRequest,
    SignupTraineeRequest,
    ChangePasswordRequest,
    ResetPasswordRequest,
    ForgotPasswordRequest,
    UpdateUserRequest,
    VerifyTrainerRequest,
    VerifyOrganizationRequest,
    Organization,
    PendingOrganization,
    PendingTrainer
} from '../Types'


/**
 * Google OAuth authentication
 * Exchanges the auth code for a token via the backend
 */
export const googleLogin = async (code: string, role: string = 'trainee'): Promise<LoginResponse> => {
    const response = await api.get<LoginResponse>(`/users/auth/google?code=${code}&state=${role}`);
    return response.data;
};

/**
 * Regular login with email and password
 */
export const login = async (credentials: LoginRequest & { otp?: string }): Promise<LoginResponse> => {
    const response = await api.post<LoginResponse>('/users/login', credentials);
    return response.data;
};

/**
 * Trainee registration
 */
export const signupTrainee = async (userData: SignupTraineeRequest): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>('/users/signup/trainee', userData);
    return response.data;
};

/**
 * Trainer registration
 */
export const signupTrainer = async (userData: SignupTrainerRequest): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>('/users/signup/trainer', userData);
    return response.data;
};

/**
 * Organization registration
 */
export const signupOrganization = async (userData: SignupOrganizationRequest): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>('/users/signup/organization', userData);
    return response.data;
};

/**
 * Get current user profile
 */
export const getCurrentUser = async (): Promise<User> => {
    const response = await api.get<User>('/users/me');
    return response.data;
};

/**
 * Update user profile
 */
export const updateUser = async (userData: UpdateUserRequest): Promise<User> => {
    const response = await api.put<User>('/users/me', userData);
    return response.data;
};

/**
 * Delete user account
 */
export const deleteUser = async (): Promise<{ message: string }> => {
    const response = await api.delete<{ message: string }>('/users/me');
    return response.data;
};

/**
 * Change password
 */
export const changePassword = async (passwordData: ChangePasswordRequest): Promise<{ message: string }> => {
    const response = await api.put<{ message: string }>('/users/change-password', passwordData);
    return response.data;
};

/**
 * Upload profile photo
 */
export const uploadProfilePhoto = async (file: File): Promise<{ message: string; profilePhoto: string }> => {
    const formData = new FormData();
    formData.append('profilePhoto', file);

    const response = await api.post<{ message: string; profilePhoto: string }>(
        '/users/upload-photo',
        formData,
        {
            headers: {
                'Content-Type': 'multipart/form-data',
            },
        }
    );
    return response.data;
};

/**
 * Upload organization documents
 */
export const uploadOrganizationDocuments = async (files: {
    profilePhoto?: File;
    registrationCertificate?: File;
    gstCertificate?: File;
    authorizationLetter?: File;
    additionalDocs?: File[];
}): Promise<{ message: string; documents: any }> => {
    const formData = new FormData();

    if (files.profilePhoto) formData.append('profilePhoto', files.profilePhoto);
    if (files.registrationCertificate) formData.append('registrationCertificate', files.registrationCertificate);
    if (files.gstCertificate) formData.append('gstCertificate', files.gstCertificate);
    if (files.authorizationLetter) formData.append('authorizationLetter', files.authorizationLetter);
    if (files.additionalDocs) {
        files.additionalDocs.forEach((file) => {
            formData.append('additionalDocs', file);
        });
    }

    const response = await api.post<{ message: string; documents: any }>(
        '/users/upload-documents',
        formData,
        {
            headers: {
                'Content-Type': 'multipart/form-data',
            },
        }
    );
    return response.data;
};

/**
 * Request password reset
 */
export const forgotPassword = async (emailData: ForgotPasswordRequest): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>('/users/forgot-password', emailData);
    return response.data;
};

/**
 * Reset password with token
 */
export const resetPassword = async (token: string, passwordData: ResetPasswordRequest): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>(`/users/reset-password/${token}`, passwordData);
    return response.data;
};

/**
 * Setup 2FA
 */
export const setup2FA = async (): Promise<{ secret: string; qrCode: string }> => {
    const response = await api.post<{ secret: string; qrCode: string }>('/users/auth/2fa/setup');
    return response.data;
};

/**
 * Verify 2FA
 */
export const verify2FA = async (token: string): Promise<{ message: string }> => {
    const response = await api.post<{ message: string }>('/users/auth/2fa/verify', { token });
    return response.data;
};

// ==================== ORGANIZATION-SPECIFIC FUNCTIONS ====================

/**
 * Verify/reject a trainer (organization only)
 */
export const verifyTrainer = async (verificationData: VerifyTrainerRequest): Promise<{
    message: string;
    trainer: {
        _id: string;
        username: string;
        email: string;
        organizationVerificationStatus: string;
    }
}> => {
    const response = await api.put<{
        message: string;
        trainer: {
            _id: string;
            username: string;
            email: string;
            organizationVerificationStatus: string;
        }
    }>('/users/verify-trainer', verificationData);
    return response.data;
};

/**
 * Get pending trainers for organization
 */
export const getPendingTrainers = async (): Promise<{
    count: number;
    trainers: PendingTrainer[]
}> => {
    const response = await api.get<{
        count: number;
        trainers: PendingTrainer[]
    }>('/users/pending-trainers');
    return response.data;
};

// ==================== ADMIN-ONLY FUNCTIONS ====================

/**
 * Verify/reject an organization (admin only)
 */
export const verifyOrganization = async (verificationData: VerifyOrganizationRequest): Promise<{
    message: string;
    organization: {
        _id: string;
        username: string;
        email: string;
        verificationStatus: string;
    }
}> => {
    const response = await api.put<{
        message: string;
        organization: {
            _id: string;
            username: string;
            email: string;
            verificationStatus: string;
        }
    }>('/users/verify-organization', verificationData);
    return response.data;
};

/**
 * Get pending organizations for admin
 */
export const getPendingOrganizations = async (): Promise<{
    count: number;
    organizations: PendingOrganization[]
}> => {
    const response = await api.get<{
        count: number;
        organizations: PendingOrganization[]
    }>('/users/pending-organizations');
    return response.data;
};

/**
 * Get all users (admin only)
 */
export const getAllUsers = async (params: {
    role?: string;
    search?: string;
    limit?: number;
    skip?: number;
    userId?: string;
}): Promise<{
    count: number;
    total: number;
    users: User[];
}> => {
    const response = await api.get<{
        count: number;
        total: number;
        users: User[];
    }>('/users/all', { params });
    return response.data;
};

// ==================== PUBLIC FUNCTIONS ====================

/**
 * Get all verified organizations (public)
 */
export const getAllOrganizations = async (): Promise<{
    count: number;
    organizations: Organization[]
}> => {
    const response = await api.get<{
        count: number;
        organizations: Organization[]
    }>('/users/organizations');
    return response.data;
};

// ==================== AUTH UTILITIES ====================

/**
 * Store token in localStorage
 */
export const storeToken = (token: string): void => {
    localStorage.setItem('token', token);
};

/**
 * Remove token from localStorage (logout)
 */
export const removeToken = (): void => {
    localStorage.removeItem('token');
};

/**
 * Get token from localStorage
 */
export const getToken = (): string | null => {
    return localStorage.getItem('token');
};

/**
 * Check if user is authenticated
 */
export const isAuthenticated = (): boolean => {
    return !!getToken();
};

/**
 * Store user data in localStorage
 */
export const storeUser = (user: User): void => {
    localStorage.setItem('user', JSON.stringify(user));
};

/**
 * Get stored user data from localStorage
 */
export const getStoredUser = (): User | null => {
    const userStr = localStorage.getItem('user');
    return userStr ? JSON.parse(userStr) : null;
};

/**
 * Remove user data from localStorage
 */
export const removeUser = (): void => {
    localStorage.removeItem('user');
};

/**
 * Logout user - clear token and user data
 */
export const logout = (): void => {
    removeToken();
    removeUser();
};

export default {
    // Auth functions
    googleLogin,
    login,
    signupTrainee,
    signupTrainer,
    signupOrganization,

    // User management
    getCurrentUser,
    updateUser,
    deleteUser,
    changePassword,
    uploadProfilePhoto,
    uploadOrganizationDocuments,

    // Password reset
    forgotPassword,
    resetPassword,
    setup2FA,
    verify2FA,

    // Organization functions
    verifyTrainer,
    getPendingTrainers,

    // Admin functions
    verifyOrganization,
    getPendingOrganizations,
    getAllUsers,

    // Public functions
    getAllOrganizations,

    // Utilities
    storeToken,
    removeToken,
    getToken,
    isAuthenticated,
    storeUser,
    getStoredUser,
    removeUser,
    logout,
};