import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError, map } from 'rxjs/operators';
import { AuthService } from '../../shared/services/auth/auth.service';

// Configuração da API - ajustar conforme environment
const API_BASE_URL = 'https://prafrota-be-bff-tenant-api.grupopra.tech';

export interface ProfileUser {
  id?: string;
  name: string;
  email: string;
  phone?: string;
  access_level?: string;
  last_login?: Date;
  login_location?: {
    city: string;
    country: string;
    ip: string;
  };
  records_modified_today?: number;
  session_duration?: number;
  security_score?: number;
  two_factor_enabled?: boolean;
  login_notifications?: boolean;
  session_timeout?: number;
  photoId?: number[]; // Array de IDs de imagens
  current_password?: string;
  new_password?: string;
  confirm_password?: string;
  created_at?: Date;
  updated_at?: Date;
}

export interface ProfileResponse {
  success: boolean;
  data: ProfileUser;
  message?: string;
  timestamp: string;
}

export interface ProfileListResponse {
  success: boolean;
  data: ProfileUser[];
  totalCount: number;
  pageCount: number;
  currentPage: number;
  timestamp: string;
}

@Injectable({
  providedIn: 'root'
})
export class  ProfileService {
  private readonly apiUrl = `${API_BASE_URL}/user`;

  constructor(
    private http: HttpClient,
    private authService: AuthService
  ) {}

  /**
   * 🔍 GET /api/v1/users/{id} - Obter dados do usuário específico
   * Baseado na documentação: TenantUserController_findOne
   */
  getUserProfile(userId: string): Observable<ProfileUser> {
    const headers = this.getHeaders();
    
    return this.http.get<ProfileResponse>(`${this.apiUrl}/${userId}`, { headers })
      .pipe(
        map(response => {
          if ( response.data) {
            return this.transformApiResponse(response.data);
          }
          throw new Error(response.message || 'Erro ao carregar perfil do usuário');
        }),
        catchError(this.handleError)
      );
  }

  /**
   * 🆕 POST /api/v1/users - Criar novo usuário
   * Baseado na documentação: TenantUserController_create
   */
  createUserProfile(profileData: Partial<ProfileUser>): Observable<ProfileUser> {
    const headers = this.getHeaders();
    const payload = this.transformToApiFormat(profileData);
    
    return this.http.post<ProfileResponse>(this.apiUrl, payload, { headers })
      .pipe(
        map(response => {
          if (response.success && response.data) {
            return this.transformApiResponse(response.data);
          }
          throw new Error(response.message || 'Erro ao criar perfil do usuário');
        }),
        catchError(this.handleError)
      );
  }

  /**
   * ✏️ PATCH /api/v1/users/{id} - Atualizar dados do usuário
   * Baseado na documentação: TenantUserController_update
   */
  updateUserProfile(userId: string, profileData: Partial<ProfileUser>): Observable<ProfileUser> {
    const headers = this.getHeaders();
    const payload = this.transformToApiFormat(profileData);
    
    return this.http.patch<ProfileResponse>(`${this.apiUrl}/${userId}`, payload, { headers })
      .pipe(
        map(response => {
          if (response.success && response.data) {
            return this.transformApiResponse(response.data);
          }
          throw new Error(response.message || 'Erro ao atualizar perfil do usuário');
        }),
        catchError(this.handleError)
      );
  }

  /**
   * 👤 GET /api/v1/users/{id} - Obter dados do usuário logado
   * Usa o ID do usuário logado do AuthService
   */
  getCurrentUserProfile(): Observable<ProfileUser> {
    const userId = this.authService.getCurrentUserId();
    if (!userId) {
      return throwError(() => new Error('Usuário não está logado'));
    }

    return this.getUserProfile(userId);
  }

  /**
   * 🔄 Método auxiliar para atualizar perfil do usuário atual
   */
  updateCurrentUserProfile(profileData: Partial<ProfileUser>): Observable<ProfileUser> {
    const userId = this.authService.getCurrentUserId();
    if (!userId) {
      return throwError(() => new Error('Usuário não está logado'));
    }

    return this.updateUserProfile(userId, profileData);
  }

  /**
   * 🔐 PATCH /api/v1/users/{id}/password - Alterar senha do usuário
   * Endpoint específico para mudança de senha
   */
  changePassword(userId: string, currentPassword: string, newPassword: string): Observable<boolean> {
    const headers = this.getHeaders();
    const payload = {
      current_password: currentPassword,
      new_password: newPassword
    };
    
    return this.http.patch<ProfileResponse>(`${this.apiUrl}/${userId}/password`, payload, { headers })
      .pipe(
        map(response => response.success),
        catchError(this.handleError)
      );
  }

  /**
   * 🖼️ PATCH /api/v1/users/{id}/photo - Atualizar foto do perfil
   * Endpoint específico para upload de foto
   */
  updateProfilePhoto(userId: string, imageIds: number[]): Observable<ProfileUser> {
    const headers = this.getHeaders();
    const payload = {
      photoId: imageIds
    };
    
    return this.http.patch<ProfileResponse>(`${this.apiUrl}/${userId}/photo`, payload, { headers })
      .pipe(
        map(response => {
          if (response.success && response.data) {
            return this.transformApiResponse(response.data);
          }
          throw new Error(response.message || 'Erro ao atualizar foto do perfil');
        }),
        catchError(this.handleError)
      );
  }

  /**
   * 📊 GET /api/v1/users/{id}/stats - Obter estatísticas do usuário
   * Dados como registros modificados, tempo de sessão, etc.
   */
  getUserStats(userId: string): Observable<any> {
    const headers = this.getHeaders();
    
    return this.http.get<any>(`${this.apiUrl}/${userId}/stats`, { headers })
      .pipe(
        map(response => {
          if (response.success) {
            return response.data;
          }
          throw new Error(response.message || 'Erro ao carregar estatísticas do usuário');
        }),
        catchError(this.handleError)
      );
  }

  /**
   * 📜 GET /api/v1/users/{id}/logs - Obter histórico de acesso
   * Para a aba de logs do perfil
   */
  getUserLogs(userId: string, page: number = 1, limit: number = 10): Observable<any> {
    const headers = this.getHeaders();
    const params = { page: page.toString(), limit: limit.toString() };
    
    return this.http.get<any>(`${this.apiUrl}/${userId}/logs`, { headers, params })
      .pipe(
        map(response => {
          if (response.success) {
            return response.data;
          }
          throw new Error(response.message || 'Erro ao carregar logs do usuário');
        }),
        catchError(this.handleError)
      );
  }

  // 🔧 MÉTODOS AUXILIARES

  /**
   * Transformar dados da API para formato do frontend
   */
  private transformApiResponse(apiData: any): ProfileUser {
    return {
      id: apiData.id,
      email: apiData.email,
      name: apiData.name || apiData.full_name,
      created_at: apiData.created_at ? new Date(apiData.created_at) : undefined,
      phone: apiData.phone,
      photoId: apiData.photoId || [],      
      updated_at: apiData.updated_at ? new Date(apiData.updated_at) : undefined,
      
      
      // access_level: apiData.access_level || apiData.role,
      // last_login: apiData.last_login ? new Date(apiData.last_login) : undefined,
      // login_location: apiData.login_location,
      // records_modified_today: apiData.records_modified_today || 0,
      // session_duration: apiData.session_duration || 0,
      // security_score: apiData.security_score || 0,
      // two_factor_enabled: apiData.two_factor_enabled || false,
      // login_notifications: apiData.login_notifications !== false, // default true
      // session_timeout: apiData.session_timeout || 30,

    };
  }

  /**
   * Transformar dados do frontend para formato da API
   */
  private transformToApiFormat(frontendData: Partial<ProfileUser>): any {
    const apiData: any = {};
    
    if (frontendData.name) apiData.name = frontendData.name;
    if (frontendData.email) apiData.email = frontendData.email;
    if (frontendData.phone) apiData.phone = frontendData.phone;
    if (frontendData.access_level) apiData.access_level = frontendData.access_level;
    if (frontendData.two_factor_enabled !== undefined) apiData.two_factor_enabled = frontendData.two_factor_enabled;
    if (frontendData.login_notifications !== undefined) apiData.login_notifications = frontendData.login_notifications;
    if (frontendData.session_timeout) apiData.session_timeout = frontendData.session_timeout;
    if (frontendData.photoId) apiData.photoId = frontendData.photoId[0];
    
    // Campos de senha (apenas se fornecidos)
    if (frontendData.current_password) apiData.current_password = frontendData.current_password;
    if (frontendData.new_password) apiData.new_password = frontendData.new_password;
    
    return apiData;
  }

  /**
   * Headers padrão para requisições
   */
  private getHeaders(): HttpHeaders {
    return new HttpHeaders({
      'Content-Type': 'application/json',
      'Accept': 'application/json'
      // Authorization será adicionado automaticamente pelo interceptor
      // X-Tenant-ID será adicionado automaticamente pelo interceptor
    });
  }

  /**
   * Tratamento de erros
   */
  private handleError = (error: any): Observable<never> => {
    let errorMessage = 'Erro desconhecido';
    
    if (error.error?.message) {
      errorMessage = error.error.message;
    } else if (error.message) {
      errorMessage = error.message;
    } else if (error.status) {
      switch (error.status) {
        case 400:
          errorMessage = 'Dados inválidos fornecidos';
          break;
        case 401:
          errorMessage = 'Não autorizado. Faça login novamente';
          break;
        case 403:
          errorMessage = 'Acesso negado';
          break;
        case 404:
          errorMessage = 'Usuário não encontrado';
          break;
        case 422:
          errorMessage = 'Dados de validação inválidos';
          break;
        case 500:
          errorMessage = 'Erro interno do servidor';
          break;
        default:
          errorMessage = `Erro HTTP: ${error.status}`;
      }
    }
    
    console.error('ProfileService Error:', error);
    return throwError(() => new Error(errorMessage));
  };
} 