import Database from 'better-sqlite3'
import path from 'path'
import fs from 'fs'
import { IDatabase, User, Client, FitnessProfile, Attendance, Recommendation, DatabaseConfig } from './types'

export class SQLiteDatabase implements IDatabase {
  private db: Database.Database | null = null
  private config: DatabaseConfig

  constructor(config: DatabaseConfig) {
    this.config = config
  }

  async connect(): Promise<void> {
    try {
      const dbPath = this.config.connection.filename || path.join(process.cwd(), 'data', 'fitai.db')

      // Ensure data directory exists
      const dataDir = path.dirname(dbPath)
      if (!fs.existsSync(dataDir)) {
        fs.mkdirSync(dataDir, { recursive: true })
      }

      this.db = new Database(dbPath)

      // Enable foreign keys
      this.db.exec('PRAGMA foreign_keys = ON')

      // Create tables
      await this.createTables()

      if (this.config.options?.logging) {
        console.log('SQLite database connected successfully at:', dbPath)
      }
    } catch (error) {
      console.error('Failed to connect to SQLite database:', error)
      throw error
    }
  }

  async disconnect(): Promise<void> {
    if (this.db) {
      this.db.close()
      this.db = null
      if (this.config.options?.logging) {
        console.log('SQLite database disconnected')
      }
    }
  }

  private async createTables(): Promise<void> {
    if (!this.db) throw new Error('Database not connected')

    // Users table
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS users (
        id TEXT PRIMARY KEY,
        email TEXT UNIQUE NOT NULL,
        firstName TEXT NOT NULL,
        lastName TEXT NOT NULL,
        password TEXT NOT NULL,
        phone TEXT,
        role TEXT NOT NULL CHECK (role IN ('superAdmin', 'admin', 'trainer', 'client')),
        createdAt DATETIME NOT NULL,
        updatedAt DATETIME NOT NULL
      )
    `)

    // Clients table
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS clients (
        id TEXT PRIMARY KEY,
        userId TEXT NOT NULL,
        membershipType TEXT NOT NULL CHECK (membershipType IN ('basic', 'premium', 'vip')),
        membershipStatus TEXT NOT NULL CHECK (membershipStatus IN ('active', 'inactive', 'expired')),
        joinDate DATETIME NOT NULL,
        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
      )
    `)

    // Fitness profiles table
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS fitness_profiles (
        userId TEXT PRIMARY KEY,
        height TEXT NOT NULL,
        weight TEXT NOT NULL,
        age TEXT NOT NULL,
        gender TEXT NOT NULL CHECK (gender IN ('male', 'female', 'other')),
        activityLevel TEXT NOT NULL CHECK (activityLevel IN ('sedentary', 'light', 'moderate', 'active', 'very_active')),
        fitnessGoals TEXT NOT NULL, -- JSON array
        exerciseHabits TEXT,
        dietHabits TEXT,
        medicalConditions TEXT,
        allergies TEXT,
        injuries TEXT,
        createdAt DATETIME NOT NULL,
        updatedAt DATETIME NOT NULL,
        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
      )
    `)

    // Create indexes for better performance
    this.db.exec(`
      CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
      CREATE INDEX IF NOT EXISTS idx_clients_userId ON clients(userId);
      CREATE INDEX IF NOT EXISTS idx_fitness_profiles_userId ON fitness_profiles(userId);
    `)

    // Attendance table
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS attendance (
        id TEXT PRIMARY KEY,
        clientId TEXT NOT NULL,
        checkInTime DATETIME NOT NULL,
        checkOutTime DATETIME,
        type TEXT NOT NULL CHECK (type IN ('gym', 'class', 'personal_training')),
        notes TEXT,
        createdAt DATETIME NOT NULL,
        FOREIGN KEY (clientId) REFERENCES clients (id) ON DELETE CASCADE
      )
    `)

    // Recommendations table
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS recommendations (
        id TEXT PRIMARY KEY,
        userId TEXT NOT NULL,
        type TEXT NOT NULL CHECK (type IN ('short_term', 'medium_term', 'long_term')),
        content TEXT NOT NULL,
        status TEXT NOT NULL CHECK (status IN ('pending', 'completed')),
        createdAt DATETIME NOT NULL,
        updatedAt DATETIME NOT NULL,
        FOREIGN KEY (userId) REFERENCES users (id) ON DELETE CASCADE
      )
    `)

    this.db.exec(`
      CREATE INDEX IF NOT EXISTS idx_recommendations_userId ON recommendations(userId);
    `)

    this.db.exec(`
      CREATE INDEX IF NOT EXISTS idx_attendance_clientId ON attendance(clientId);
      CREATE INDEX IF NOT EXISTS idx_attendance_checkInTime ON attendance(checkInTime);
    `)
  }

  // User operations
  async createUser(userData: Omit<User, 'createdAt' | 'updatedAt'>): Promise<User> {
    if (!this.db) throw new Error('Database not connected')

    const id = userData.id || Math.random().toString(36).substr(2, 9)
    const now = new Date()

    const user: User = {
      ...userData,
      id,
      createdAt: now,
      updatedAt: now
    }

    const stmt = this.db.prepare(
      `INSERT INTO users(id, email, firstName, lastName, password, phone, role, createdAt, updatedAt)
    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)`
    )

    stmt.run(
      user.id, user.email, user.firstName, user.lastName, user.password,
      user.phone, user.role, user.createdAt.toISOString(), user.updatedAt.toISOString()
    )

    return user
  }

  async getUserById(id: string): Promise<User | null> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM users WHERE id = ?')
    const row = stmt.get(id)

    return row ? this.mapRowToUser(row) : null
  }

  async getUserByEmail(email: string): Promise<User | null> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM users WHERE email = ?')
    const row = stmt.get(email)

    return row ? this.mapRowToUser(row) : null
  }

  async getAllUsers(): Promise<User[]> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM users ORDER BY createdAt DESC')
    const rows = stmt.all()

    return rows.map(row => this.mapRowToUser(row))
  }

  async updateUser(id: string, updates: Partial<User>): Promise<User | null> {
    if (!this.db) throw new Error('Database not connected')

    const fields = Object.keys(updates).filter(key => key !== 'id')
    if (fields.length === 0) return this.getUserById(id)

    const setClause = fields.map(field => `${field} = ?`).join(', ')
    const values = fields.map(field => (updates as any)[field])
    values.push(new Date().toISOString()) // updatedAt
    values.push(id)

    const stmt = this.db.prepare(`UPDATE users SET ${setClause}, updatedAt = ? WHERE id = ? `)
    stmt.run(values)

    return this.getUserById(id)
  }

  async deleteUser(id: string): Promise<boolean> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('DELETE FROM users WHERE id = ?')
    const result = stmt.run(id)
    return (result.changes || 0) > 0
  }

  async migrateUserId(oldId: string, newId: string): Promise<void> {
    if (!this.db) throw new Error('Database not connected')

    // We need to disable foreign keys temporarily if we want to update ID without cascade (if cascade isn't set)
    // But we should try to update and let cascade handle it if possible.
    // Since we didn't set ON UPDATE CASCADE, we might need to manually update references or use PRAGMA.

    // Simplest way: Update the ID. If it fails due to FK, we have to handle it.
    // For the Super Admin seed case, there are no dependencies.

    const stmt = this.db.prepare('UPDATE users SET id = ? WHERE id = ?')
    stmt.run(newId, oldId)
  }

  // Client operations
  async createClient(clientData: Omit<Client, 'id'>): Promise<Client> {
    if (!this.db) throw new Error('Database not connected')

    const id = Math.random().toString(36).substr(2, 9)
    const client: Client = { id, ...clientData }

    const stmt = this.db.prepare(
      `INSERT INTO clients(id, userId, membershipType, membershipStatus, joinDate)
    VALUES(?, ?, ?, ?, ?)`
    )

    stmt.run(
      client.id, client.userId, client.membershipType,
      client.membershipStatus, client.joinDate.toISOString()
    )

    return client
  }

  async getClientById(id: string): Promise<Client | null> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM clients WHERE id = ?')
    const row = stmt.get(id)
    return row ? this.mapRowToClient(row) : null
  }

  async getClientByUserId(userId: string): Promise<Client | null> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM clients WHERE userId = ?')
    const row = stmt.get(userId)
    return row ? this.mapRowToClient(row) : null
  }

  async getAllClients(): Promise<Client[]> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM clients ORDER BY joinDate DESC')
    const rows = stmt.all()
    return rows.map(row => this.mapRowToClient(row))
  }

  async updateClient(id: string, updates: Partial<Client>): Promise<Client | null> {
    if (!this.db) throw new Error('Database not connected')

    const fields = Object.keys(updates).filter(key => key !== 'id')
    if (fields.length === 0) return this.getClientById(id)

    const setClause = fields.map(field => `${field} = ?`).join(', ')
    const values = fields.map(field => (updates as any)[field])
    values.push(id)

    const stmt = this.db.prepare(`UPDATE clients SET ${setClause} WHERE id = ? `)
    stmt.run(values)

    return this.getClientById(id)
  }

  async deleteClient(id: string): Promise<boolean> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('DELETE FROM clients WHERE id = ?')
    const result = stmt.run(id)
    return (result.changes || 0) > 0
  }

  // Fitness Profile operations
  async createFitnessProfile(profileData: Omit<FitnessProfile, 'createdAt' | 'updatedAt'>): Promise<FitnessProfile> {
    if (!this.db) throw new Error('Database not connected')

    const now = new Date()
    const profile: FitnessProfile = {
      ...profileData,
      createdAt: now,
      updatedAt: now
    }

    const stmt = this.db.prepare(
      `INSERT INTO fitness_profiles
      (userId, height, weight, age, gender, activityLevel, fitnessGoals,
        exerciseHabits, dietHabits, medicalConditions, allergies, injuries, createdAt, updatedAt)
    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
    )

    stmt.run(
      profile.userId, profile.height, profile.weight, profile.age, profile.gender,
      profile.activityLevel, JSON.stringify(profile.fitnessGoals), profile.exerciseHabits,
      profile.dietHabits, profile.medicalConditions, profile.allergies, profile.injuries,
      profile.createdAt.toISOString(), profile.updatedAt.toISOString()
    )

    return profile
  }

  async getFitnessProfileByUserId(userId: string): Promise<FitnessProfile | null> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM fitness_profiles WHERE userId = ?')
    const row = stmt.get(userId)

    return row ? this.mapRowToFitnessProfile(row) : null
  }

  async getAllFitnessProfiles(): Promise<FitnessProfile[]> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM fitness_profiles ORDER BY createdAt DESC')
    const rows = stmt.all()
    return rows.map(row => this.mapRowToFitnessProfile(row))
  }

  async updateFitnessProfile(userId: string, updates: Partial<FitnessProfile>): Promise<FitnessProfile | null> {
    if (!this.db) throw new Error('Database not connected')

    const fields = Object.keys(updates).filter(key => key !== 'userId' && key !== 'createdAt')
    if (fields.length === 0) return this.getFitnessProfileByUserId(userId)

    const setClause = fields.map(field => `${field} = ?`).join(', ')
    const values = fields.map(field => {
      const value = (updates as any)[field]
      return field === 'fitnessGoals' ? JSON.stringify(value) : value
    })
    values.push(new Date().toISOString()) // updatedAt
    values.push(userId)

    const stmt = this.db.prepare(`UPDATE fitness_profiles SET ${setClause}, updatedAt = ? WHERE userId = ? `)
    stmt.run(values)

    return this.getFitnessProfileByUserId(userId)
  }

  async deleteFitnessProfile(userId: string): Promise<boolean> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('DELETE FROM fitness_profiles WHERE userId = ?')
    const result = stmt.run(userId)
    return (result.changes || 0) > 0
  }

  // Attendance operations
  async checkIn(clientId: string, type: 'gym' | 'class' | 'personal_training', notes?: string): Promise<Attendance> {
    if (!this.db) throw new Error('Database not connected')

    const id = Math.random().toString(36).substr(2, 9)
    const now = new Date()

    const attendance: Attendance = {
      id,
      clientId,
      checkInTime: now,
      type,
      notes,
      createdAt: now
    }

    const stmt = this.db.prepare(
      `INSERT INTO attendance(id, clientId, checkInTime, type, notes, createdAt)
    VALUES(?, ?, ?, ?, ?, ?)`
    )

    stmt.run(
      attendance.id, attendance.clientId, attendance.checkInTime.toISOString(),
      attendance.type, attendance.notes, attendance.createdAt.toISOString()
    )

    // Update client last visit
    this.db.prepare('UPDATE clients SET lastVisit = ? WHERE id = ?').run(
      now.toISOString(),
      clientId
    )

    return attendance
  }

  async checkOut(attendanceId: string): Promise<Attendance | null> {
    if (!this.db) throw new Error('Database not connected')

    const now = new Date()
    const stmt = this.db.prepare('UPDATE attendance SET checkOutTime = ? WHERE id = ?')
    stmt.run(now.toISOString(), attendanceId)

    return this.getAttendanceById(attendanceId)
  }

  async getAttendanceById(id: string): Promise<Attendance | null> {
    if (!this.db) throw new Error('Database not connected')
    const stmt = this.db.prepare('SELECT * FROM attendance WHERE id = ?')
    const row = stmt.get(id)
    return row ? this.mapRowToAttendance(row) : null
  }

  async getAttendanceHistory(clientId: string): Promise<Attendance[]> {
    if (!this.db) throw new Error('Database not connected')
    const stmt = this.db.prepare('SELECT * FROM attendance WHERE clientId = ? ORDER BY checkInTime DESC')
    const rows = stmt.all(clientId)
    return rows.map(row => this.mapRowToAttendance(row))
  }

  async getAllAttendance(): Promise<Attendance[]> {
    if (!this.db) throw new Error('Database not connected')
    const stmt = this.db.prepare('SELECT * FROM attendance ORDER BY checkInTime DESC')
    const rows = stmt.all()
    return rows.map(row => this.mapRowToAttendance(row))
  }

  async getActiveCheckIn(clientId: string): Promise<Attendance | null> {
    if (!this.db) throw new Error('Database not connected')
    const stmt = this.db.prepare('SELECT * FROM attendance WHERE clientId = ? AND checkOutTime IS NULL ORDER BY checkInTime DESC LIMIT 1')
    const row = stmt.get(clientId)
    return row ? this.mapRowToAttendance(row) : null
  }

  // Helper methods to map database rows to entities
  private mapRowToUser(row: any): User {
    return {
      id: row.id,
      email: row.email,
      firstName: row.firstName,
      lastName: row.lastName,
      password: row.password,
      phone: row.phone,
      role: row.role,
      createdAt: new Date(row.createdAt),
      updatedAt: new Date(row.updatedAt)
    }
  }

  private mapRowToClient(row: any): Client {
    return {
      id: row.id,
      userId: row.userId,
      membershipType: row.membershipType,
      membershipStatus: row.membershipStatus,
      joinDate: new Date(row.joinDate),
      lastVisit: row.lastVisit ? new Date(row.lastVisit) : undefined
    }
  }

  private mapRowToFitnessProfile(row: any): FitnessProfile {
    return {
      userId: row.userId,
      height: row.height,
      weight: row.weight,
      age: row.age,
      gender: row.gender,
      activityLevel: row.activityLevel,
      fitnessGoals: JSON.parse(row.fitnessGoals || '[]'),
      exerciseHabits: row.exerciseHabits,
      dietHabits: row.dietHabits,
      medicalConditions: row.medicalConditions,
      allergies: row.allergies,
      injuries: row.injuries,
      createdAt: new Date(row.createdAt),
      updatedAt: new Date(row.updatedAt)
    }
  }

  private mapRowToAttendance(row: any): Attendance {
    return {
      id: row.id,
      clientId: row.clientId,
      checkInTime: new Date(row.checkInTime),
      checkOutTime: row.checkOutTime ? new Date(row.checkOutTime) : undefined,
      type: row.type,
      notes: row.notes,
      createdAt: new Date(row.createdAt)
    }
  }

  // Recommendation operations
  async createRecommendation(data: Omit<Recommendation, 'createdAt' | 'updatedAt'>): Promise<Recommendation> {
    if (!this.db) throw new Error('Database not connected')

    const now = new Date()
    const recommendation: Recommendation = {
      ...data,
      createdAt: now,
      updatedAt: now
    }

    const stmt = this.db.prepare(
      `INSERT INTO recommendations (id, userId, type, content, status, createdAt, updatedAt)
       VALUES (?, ?, ?, ?, ?, ?, ?)`
    )

    stmt.run(
      recommendation.id, recommendation.userId, recommendation.type,
      recommendation.content, recommendation.status,
      recommendation.createdAt.toISOString(), recommendation.updatedAt.toISOString()
    )

    return recommendation
  }

  async getRecommendationsByUserId(userId: string): Promise<Recommendation[]> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('SELECT * FROM recommendations WHERE userId = ? ORDER BY createdAt DESC')
    const rows = stmt.all(userId)

    return rows.map(row => this.mapRowToRecommendation(row))
  }

  async updateRecommendation(id: string, updates: Partial<Recommendation>): Promise<Recommendation | null> {
    if (!this.db) throw new Error('Database not connected')

    const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'userId')
    if (fields.length === 0) {
      const stmt = this.db.prepare('SELECT * FROM recommendations WHERE id = ?')
      const row = stmt.get(id)
      return row ? this.mapRowToRecommendation(row) : null
    }

    const setClause = fields.map(field => `${field} = ?`).join(', ')
    const values = fields.map(field => (updates as any)[field])
    values.push(new Date().toISOString()) // updatedAt
    values.push(id)

    const stmt = this.db.prepare(`UPDATE recommendations SET ${setClause}, updatedAt = ? WHERE id = ?`)
    stmt.run(values)

    const getStmt = this.db.prepare('SELECT * FROM recommendations WHERE id = ?')
    const row = getStmt.get(id)
    return row ? this.mapRowToRecommendation(row) : null
  }

  async deleteRecommendation(id: string): Promise<boolean> {
    if (!this.db) throw new Error('Database not connected')

    const stmt = this.db.prepare('DELETE FROM recommendations WHERE id = ?')
    const result = stmt.run(id)
    return (result.changes || 0) > 0
  }

  private mapRowToRecommendation(row: any): Recommendation {
    return {
      id: row.id,
      userId: row.userId,
      type: row.type,
      content: row.content,
      status: row.status,
      createdAt: new Date(row.createdAt),
      updatedAt: new Date(row.updatedAt)
    }
  }

  async getDashboardStats(): Promise<{
    totalUsers: number;
    activeClients: number;
    totalRevenue: number;
    revenueGrowth: number;
  }> {
    if (!this.db) throw new Error('Database not connected')

    // Total Users
    const userCountStmt = this.db.prepare('SELECT COUNT(*) as count FROM users')
    const userCount = (userCountStmt.get() as any).count

    // Active Clients
    const activeClientCountStmt = this.db.prepare("SELECT COUNT(*) as count FROM clients WHERE membershipStatus = 'active'")
    const activeClientCount = (activeClientCountStmt.get() as any).count

    // Total Revenue (assuming payments table exists, handling if it's empty)
    // Note: We need to create the payments table first if it doesn't exist in createTables
    // For now, returning 0 if table doesn't exist or is empty
    let totalRevenue = 0
    let revenueGrowth = 0

    try {
      const revenueStmt = this.db.prepare('SELECT SUM(amount) as total FROM payments WHERE status = "completed"')
      const revenueResult = revenueStmt.get() as any
      totalRevenue = revenueResult?.total || 0
    } catch (e) {
      // Table might not exist yet
      console.warn('Payments table query failed, returning 0 revenue')
    }

    return {
      totalUsers: userCount,
      activeClients: activeClientCount,
      totalRevenue,
      revenueGrowth
    }
  }
}