import Foundation
import SwiftData

final class AppContainer {
    static let logger = AppLogger(
        subsystem: Bundle.main.bundleIdentifier ?? "dev.rzen.indie.Workouts.watchkitapp",
        category: "AppContainer"
    )
    
    static func create() -> ModelContainer {
        // Using the current models directly without migration plan to avoid reference errors
        let schema = Schema(SchemaVersion.models)
        
        #if targetEnvironment(simulator) && os(watchOS)
            // Use local-only storage for watchOS simulator
            let configuration = ModelConfiguration(isStoredInMemoryOnly: false)
            logger.info("Creating local-only database for watchOS simulator")
            
            do {
                let container = try ModelContainer(for: schema, configurations: configuration)
                
                // Populate with test data if needed
                Task { @MainActor in
                    await populateSimulatorData(container: container)
                }
                
                return container
            } catch {
                logger.error("Failed to create simulator ModelContainer: \(error.localizedDescription)")
                fatalError("Failed to create simulator ModelContainer: \(error.localizedDescription)")
            }
        #else
            // Use CloudKit for real devices
            let configuration = ModelConfiguration(cloudKitDatabase: .automatic)
            logger.info("Creating CloudKit database for real device")
            
            let container = try! ModelContainer(for: schema, configurations: configuration)
            return container
        #endif
    }
    
    @MainActor
    static var preview: ModelContainer {
        let configuration = ModelConfiguration(isStoredInMemoryOnly: true)
        
        do {
            let schema = Schema(SchemaVersion.models)
            let container = try ModelContainer(for: schema, configurations: configuration)
            return container
        } catch {
            fatalError("Failed to create preview ModelContainer: \(error.localizedDescription)")
        }
    }
    
    @MainActor
    private static func populateSimulatorData(container: ModelContainer) async {
        let context = container.mainContext
        
        // Check if data already exists
        let fetchDescriptor = FetchDescriptor<Split>()
        guard (try? context.fetch(fetchDescriptor))?.isEmpty ?? true else {
            logger.info("Simulator database already has data, skipping population")
            return // Data already exists
        }
        
        logger.info("Populating simulator database with test data from pf-starter-exercises.yaml")
        
        // Create splits
        let upperBodySplit = Split(name: "Upper Body", color: "blue", systemImage: "figure.strengthtraining.traditional", order: 0)
        let lowerBodySplit = Split(name: "Lower Body", color: "green", systemImage: "figure.run", order: 1)
        let fullBodySplit = Split(name: "Full Body", color: "purple", systemImage: "figure.mixed.cardio", order: 2)
        let coreSplit = Split(name: "Core", color: "red", systemImage: "figure.core.training", order: 3)
        
        context.insert(upperBodySplit)
        context.insert(lowerBodySplit)
        context.insert(fullBodySplit)
        context.insert(coreSplit)
        
        // Create exercises based on pf-starter-exercises.yaml
        
        // Upper Body Exercises
        let latPullDown = Exercise(split: upperBodySplit, exerciseName: "Lat Pull Down", order: 0, sets: 3, reps: 12, weight: 120)
        let seatedRow = Exercise(split: upperBodySplit, exerciseName: "Seated Row", order: 1, sets: 3, reps: 12, weight: 110)
        let shoulderPress = Exercise(split: upperBodySplit, exerciseName: "Shoulder Press", order: 2, sets: 3, reps: 10, weight: 90)
        let chestPress = Exercise(split: upperBodySplit, exerciseName: "Chest Press", order: 3, sets: 3, reps: 10, weight: 130)
        let tricepPress = Exercise(split: upperBodySplit, exerciseName: "Tricep Press", order: 4, sets: 3, reps: 12, weight: 70)
        let armCurl = Exercise(split: upperBodySplit, exerciseName: "Arm Curl", order: 5, sets: 3, reps: 12, weight: 60)
        
        context.insert(latPullDown)
        context.insert(seatedRow)
        context.insert(shoulderPress)
        context.insert(chestPress)
        context.insert(tricepPress)
        context.insert(armCurl)
        
        // Core Exercises
        let abdominal = Exercise(split: coreSplit, exerciseName: "Abdominal", order: 0, sets: 3, reps: 15, weight: 80)
        let rotary = Exercise(split: coreSplit, exerciseName: "Rotary", order: 1, sets: 3, reps: 15, weight: 70)
        let plank = Exercise(split: coreSplit, exerciseName: "Plank", order: 2, sets: 3, reps: 1, weight: 0) // Reps as time in minutes
        let russianTwists = Exercise(split: coreSplit, exerciseName: "Russian Twists", order: 3, sets: 3, reps: 20, weight: 25)
        
        context.insert(abdominal)
        context.insert(rotary)
        context.insert(plank)
        context.insert(russianTwists)
        
        // Lower Body Exercises
        let legPress = Exercise(split: lowerBodySplit, exerciseName: "Leg Press", order: 0, sets: 3, reps: 12, weight: 200)
        let legExtension = Exercise(split: lowerBodySplit, exerciseName: "Leg Extension", order: 1, sets: 3, reps: 12, weight: 110)
        let legCurl = Exercise(split: lowerBodySplit, exerciseName: "Leg Curl", order: 2, sets: 3, reps: 12, weight: 90)
        let adductor = Exercise(split: lowerBodySplit, exerciseName: "Adductor", order: 3, sets: 3, reps: 15, weight: 100)
        let abductor = Exercise(split: lowerBodySplit, exerciseName: "Abductor", order: 4, sets: 3, reps: 15, weight: 90)
        let calfs = Exercise(split: lowerBodySplit, exerciseName: "Calfs", order: 5, sets: 3, reps: 15, weight: 120)
        
        context.insert(legPress)
        context.insert(legExtension)
        context.insert(legCurl)
        context.insert(adductor)
        context.insert(abductor)
        context.insert(calfs)
        
        // Full Body Exercises (selected from both upper and lower)
        let fullBodyChestPress = Exercise(split: fullBodySplit, exerciseName: "Chest Press", order: 0, sets: 3, reps: 10, weight: 130)
        let fullBodyLatPullDown = Exercise(split: fullBodySplit, exerciseName: "Lat Pull Down", order: 1, sets: 3, reps: 12, weight: 120)
        let fullBodyLegPress = Exercise(split: fullBodySplit, exerciseName: "Leg Press", order: 2, sets: 3, reps: 12, weight: 200)
        let fullBodyAbdominal = Exercise(split: fullBodySplit, exerciseName: "Abdominal", order: 3, sets: 3, reps: 15, weight: 80)
        
        context.insert(fullBodyChestPress)
        context.insert(fullBodyLatPullDown)
        context.insert(fullBodyLegPress)
        context.insert(fullBodyAbdominal)
        
        // Create workouts
        let now = Date()
        
        // Upper Body Workout (in progress)
        let upperBodyWorkout = Workout(start: now, end: now, split: upperBodySplit)
        upperBodyWorkout.status = 2
//        upperBodyWorkout.status = .inProgress
        upperBodyWorkout.end = nil
        context.insert(upperBodyWorkout)
        
        // Lower Body Workout (scheduled for tomorrow)
        let tomorrow = Calendar.current.date(byAdding: .day, value: 1, to: now) ?? now
        let lowerBodyWorkout = Workout(start: tomorrow, end: tomorrow, split: lowerBodySplit)
        lowerBodyWorkout.status = 1
//        lowerBodyWorkout.status = .notStarted
        context.insert(lowerBodyWorkout)
        
        // Full Body Workout (completed yesterday)
        let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: now) ?? now
        let fullBodyWorkout = Workout(start: yesterday, end: yesterday, split: fullBodySplit)
        fullBodyWorkout.status = 3
//        fullBodyWorkout.status = .completed
        context.insert(fullBodyWorkout)
        
        // Create workout logs for Upper Body workout (in progress)
        let chestPressLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: chestPress.name, date: now, order: 0, sets: chestPress.sets, reps: chestPress.reps, weight: chestPress.weight, status: .completed, completed: true)
        let shoulderPressLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: shoulderPress.name, date: now, order: 1, sets: shoulderPress.sets, reps: shoulderPress.reps, weight: shoulderPress.weight, status: .completed, completed: true)
        let latPullDownLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: latPullDown.name, date: now, order: 2, sets: latPullDown.sets, reps: latPullDown.reps, weight: latPullDown.weight, status: .inProgress, completed: false)
        let seatedRowLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: seatedRow.name, date: now, order: 3, sets: seatedRow.sets, reps: seatedRow.reps, weight: seatedRow.weight, status: .notStarted, completed: false)
        let tricepPressLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: tricepPress.name, date: now, order: 4, sets: tricepPress.sets, reps: tricepPress.reps, weight: tricepPress.weight, status: .notStarted, completed: false)
        let armCurlLog = WorkoutLog(workout: upperBodyWorkout, exerciseName: armCurl.name, date: now, order: 5, sets: armCurl.sets, reps: armCurl.reps, weight: armCurl.weight, status: .notStarted, completed: false)
        
        context.insert(chestPressLog)
        context.insert(shoulderPressLog)
        context.insert(latPullDownLog)
        context.insert(seatedRowLog)
        context.insert(tricepPressLog)
        context.insert(armCurlLog)
        
        // Create workout logs for Lower Body workout (scheduled)
        let legPressLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: legPress.name, date: tomorrow, order: 0, sets: legPress.sets, reps: legPress.reps, weight: legPress.weight, status: .notStarted, completed: false)
        let legExtensionLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: legExtension.name, date: tomorrow, order: 1, sets: legExtension.sets, reps: legExtension.reps, weight: legExtension.weight, status: .notStarted, completed: false)
        let legCurlLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: legCurl.name, date: tomorrow, order: 2, sets: legCurl.sets, reps: legCurl.reps, weight: legCurl.weight, status: .notStarted, completed: false)
        let adductorLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: adductor.name, date: tomorrow, order: 3, sets: adductor.sets, reps: adductor.reps, weight: adductor.weight, status: .notStarted, completed: false)
        let abductorLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: abductor.name, date: tomorrow, order: 4, sets: abductor.sets, reps: abductor.reps, weight: abductor.weight, status: .notStarted, completed: false)
        let calfsLog = WorkoutLog(workout: lowerBodyWorkout, exerciseName: calfs.name, date: tomorrow, order: 5, sets: calfs.sets, reps: calfs.reps, weight: calfs.weight, status: .notStarted, completed: false)
        
        context.insert(legPressLog)
        context.insert(legExtensionLog)
        context.insert(legCurlLog)
        context.insert(adductorLog)
        context.insert(abductorLog)
        context.insert(calfsLog)
        
        // Create workout logs for Full Body workout (completed)
        let fullBodyChestPressLog = WorkoutLog(workout: fullBodyWorkout, exerciseName: fullBodyChestPress.name, date: yesterday, order: 0, sets: fullBodyChestPress.sets, reps: fullBodyChestPress.reps, weight: fullBodyChestPress.weight, status: .completed, completed: true)
        let fullBodyLatPullDownLog = WorkoutLog(workout: fullBodyWorkout, exerciseName: fullBodyLatPullDown.name, date: yesterday, order: 1, sets: fullBodyLatPullDown.sets, reps: fullBodyLatPullDown.reps, weight: fullBodyLatPullDown.weight, status: .completed, completed: true)
        let fullBodyLegPressLog = WorkoutLog(workout: fullBodyWorkout, exerciseName: fullBodyLegPress.name, date: yesterday, order: 2, sets: fullBodyLegPress.sets, reps: fullBodyLegPress.reps, weight: fullBodyLegPress.weight, status: .completed, completed: true)
        let fullBodyAbdominalLog = WorkoutLog(workout: fullBodyWorkout, exerciseName: fullBodyAbdominal.name, date: yesterday, order: 3, sets: fullBodyAbdominal.sets, reps: fullBodyAbdominal.reps, weight: fullBodyAbdominal.weight, status: .completed, completed: true)
        
        context.insert(fullBodyChestPressLog)
        context.insert(fullBodyLatPullDownLog)
        context.insert(fullBodyLegPressLog)
        context.insert(fullBodyAbdominalLog)
        
        do {
            try context.save()
            logger.info("Successfully populated simulator database with test data from pf-starter-exercises.yaml")
        } catch {
            logger.error("Failed to save test data: \(error.localizedDescription)")
        }
    }
}