// Tipos para o banco de dados local
export interface ProfileData {
  id: string
  name: string
  email: string
  phone: string
  bio: string
  profileImage?: string
  createdAt: string
  updatedAt: string
}

export interface User {
  id: string
  username: string
  profileData: ProfileData
}

// Classe para gerenciar o banco de dados local
class LocalDatabase {
  private readonly STORAGE_KEY = 'todai_jobs_db'
  
  // Inicializar o banco se não existir
  private initializeDB(): void {
    if (!localStorage.getItem(this.STORAGE_KEY)) {
      const initialDB = {
        users: [],
        currentUserId: null,
        version: '1.0.0'
      }
      localStorage.setItem(this.STORAGE_KEY, JSON.stringify(initialDB))
    }
  }

  // Obter dados do banco
  private getDB() {
    this.initializeDB()
    const data = localStorage.getItem(this.STORAGE_KEY)
    return data ? JSON.parse(data) : { users: [], currentUserId: null }
  }

  // Salvar dados no banco
  private saveDB(data: any): void {
    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(data))
  }

  // Converter File para base64 string
  private async fileToBase64(file: File): Promise<string> {
    return new Promise((resolve, reject) => {
      const reader = new FileReader()
      reader.readAsDataURL(file)
      reader.onload = () => resolve(reader.result as string)
      reader.onerror = error => reject(error)
    })
  }

  // Gerar ID único
  private generateId(): string {
    return Date.now().toString(36) + Math.random().toString(36).substr(2)
  }

  // Criar usuário padrão se não existir
  public async createDefaultUser(): Promise<User> {
    const db = this.getDB()
    
    if (db.users.length === 0) {
      const defaultUser: User = {
        id: this.generateId(),
        username: 'usuario_padrao',
        profileData: {
          id: this.generateId(),
          name: '',
          email: '',
          phone: '',
          bio: '',
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString()
        }
      }
      
      db.users.push(defaultUser)
      db.currentUserId = defaultUser.id
      this.saveDB(db)
      
      return defaultUser
    }
    
    return db.users[0]
  }

  // Obter usuário atual
  public getCurrentUser(): User | null {
    const db = this.getDB()
    if (db.currentUserId) {
      return db.users.find((user: User) => user.id === db.currentUserId) || null
    }
    return db.users[0] || null
  }

  // Salvar foto de perfil
  public async saveProfileImage(file: File): Promise<string> {
    try {
      const base64Image = await this.fileToBase64(file)
      const db = this.getDB()
      const currentUser = this.getCurrentUser()
      
      if (!currentUser) {
        await this.createDefaultUser()
        return this.saveProfileImage(file)
      }

      // Atualizar a imagem do perfil do usuário
      const userIndex = db.users.findIndex((user: User) => user.id === currentUser.id)
      if (userIndex !== -1) {
        db.users[userIndex].profileData.profileImage = base64Image
        db.users[userIndex].profileData.updatedAt = new Date().toISOString()
        this.saveDB(db)
      }

      return base64Image
    } catch (error) {
      console.error('Erro ao salvar imagem:', error)
      throw new Error('Falha ao salvar imagem no banco local')
    }
  }

  // Obter foto de perfil
  public getProfileImage(): string | null {
    const currentUser = this.getCurrentUser()
    return currentUser?.profileData.profileImage || null
  }

  // Remover foto de perfil
  public removeProfileImage(): void {
    const db = this.getDB()
    const currentUser = this.getCurrentUser()
    
    if (currentUser) {
      const userIndex = db.users.findIndex((user: User) => user.id === currentUser.id)
      if (userIndex !== -1) {
        delete db.users[userIndex].profileData.profileImage
        db.users[userIndex].profileData.updatedAt = new Date().toISOString()
        this.saveDB(db)
      }
    }
  }

  // Salvar dados do perfil
  public saveProfileData(profileData: Partial<ProfileData>): void {
    const db = this.getDB()
    const currentUser = this.getCurrentUser()
    
    if (currentUser) {
      const userIndex = db.users.findIndex((user: User) => user.id === currentUser.id)
      if (userIndex !== -1) {
        db.users[userIndex].profileData = {
          ...db.users[userIndex].profileData,
          ...profileData,
          updatedAt: new Date().toISOString()
        }
        this.saveDB(db)
      }
    }
  }

  // Obter dados do perfil
  public getProfileData(): ProfileData | null {
    const currentUser = this.getCurrentUser()
    return currentUser?.profileData || null
  }

  // Limpar todos os dados (para desenvolvimento)
  public clearAllData(): void {
    localStorage.removeItem(this.STORAGE_KEY)
  }

  // Exportar dados (para backup)
  public exportData(): string {
    return localStorage.getItem(this.STORAGE_KEY) || '{}'
  }

  // Importar dados (para restore)
  public importData(data: string): void {
    try {
      JSON.parse(data) // Validar se é JSON válido
      localStorage.setItem(this.STORAGE_KEY, data)
    } catch (error) {
      throw new Error('Dados inválidos para importação')
    }
  }
}

// Instância singleton do banco de dados
export const localDB = new LocalDatabase()