//
//  ChargingWindowDetector.swift
//  USB Meter
//

import Foundation

enum ChargingWindowDetector {

    struct DetectedWindow {
        let start: Date
        let end: Date
        // How much shorter the window is vs total session (0..1). Higher = more trimming needed.
        let trimRatio: Double
    }

    // Power above this threshold counts as "charging activity" (Watts)
    private static let activityThreshold = 0.05
    // A charging segment must last at least this long to be considered real
    private static let minimumSegmentDuration: TimeInterval = 3 * 60
    // Gaps shorter than this between active segments are bridged (e.g. brief wireless drop)
    private static let mergeGapDuration: TimeInterval = 120
    // Padding added before first and after last sample of the detected window
    private static let padding: TimeInterval = 30
    // Only surface detection when active window is shorter than this fraction of total session
    // e.g. 0.30 means: show banner if active charging < 70% of total session time
    static let significantTrimThreshold = 0.30

    static func detect(
        samples: [ChargeSessionSampleSummary],
        sessionStart: Date,
        sessionEnd: Date
    ) -> DetectedWindow? {
        guard !samples.isEmpty else { return nil }
        let sorted = samples.sorted { $0.timestamp < $1.timestamp }

        // Build contiguous active segments
        struct Segment { var start: Date; var end: Date }
        var segments: [Segment] = []
        var segStart: Date?
        var segEnd: Date?

        for sample in sorted {
            if sample.averagePowerWatts >= activityThreshold {
                if segStart == nil { segStart = sample.timestamp }
                segEnd = sample.timestamp
            } else {
                if let s = segStart, let e = segEnd {
                    segments.append(Segment(start: s, end: e))
                }
                segStart = nil
                segEnd = nil
            }
        }
        if let s = segStart, let e = segEnd {
            segments.append(Segment(start: s, end: e))
        }

        guard !segments.isEmpty else { return nil }

        // Merge segments separated by short gaps
        var merged: [Segment] = [segments[0]]
        for seg in segments.dropFirst() {
            let gap = seg.start.timeIntervalSince(merged[merged.count - 1].end)
            if gap <= mergeGapDuration {
                merged[merged.count - 1].end = seg.end
            } else {
                merged.append(seg)
            }
        }

        // Filter out short segments
        let significant = merged.filter {
            $0.end.timeIntervalSince($0.start) >= minimumSegmentDuration
        }

        guard !significant.isEmpty else { return nil }

        // Pick primary segment: the longest one
        let primary = significant.max { a, b in
            a.end.timeIntervalSince(a.start) < b.end.timeIntervalSince(b.start)
        }!

        let windowStart = max(sessionStart, primary.start.addingTimeInterval(-padding))
        let windowEnd   = min(sessionEnd,   primary.end.addingTimeInterval(padding))

        let sessionDuration = sessionEnd.timeIntervalSince(sessionStart)
        let windowDuration  = windowEnd.timeIntervalSince(windowStart)
        guard sessionDuration > 0 else { return nil }

        let trimRatio = 1.0 - (windowDuration / sessionDuration)
        return DetectedWindow(start: windowStart, end: windowEnd, trimRatio: trimRatio)
    }
}