//

//  SessionTrimEditorView.swift

//  USB Meter

//

import SwiftUI

struct SessionTrimEditorView: View {

    let session: ChargeSessionSummary

    let liveTimeRange: ClosedRange<Date>?

    let onApply: (Date?, Date?) -> Void

    let onDismiss: () -> Void

    @State private var trimStart: Date

    @State private var trimEnd: Date

    private var fullStart: Date { liveTimeRange?.lowerBound ?? session.startedAt }

    private var fullEnd: Date   { liveTimeRange?.upperBound ?? (session.endedAt ?? session.lastObservedAt) }

    private var sessionDuration: TimeInterval { max(fullEnd.timeIntervalSince(fullStart), 1) }

    private var startFraction: Double {

        trimStart.timeIntervalSince(fullStart) / sessionDuration

    }

    private var endFraction: Double {

        trimEnd.timeIntervalSince(fullStart) / sessionDuration

    }

    // Energy preview from cumulative sample values

    private var previewEnergyWh: Double {

        let sorted = session.aggregatedSamples.sorted { $0.timestamp < $1.timestamp }

        let baseline = sorted.last { $0.timestamp <= trimStart }

        guard let endSample = sorted.last(where: { $0.timestamp <= trimEnd }) else { return 0 }

        return max(endSample.measuredEnergyWh - (baseline?.measuredEnergyWh ?? 0), 0)

    }

    private var trimmedDuration: TimeInterval {

        max(trimEnd.timeIntervalSince(trimStart), 0)

    }

    private var checkpointsToRemove: [ChargeCheckpointSummary] {

        session.checkpoints.filter { $0.timestamp < trimStart || $0.timestamp > trimEnd }

    }

    private var isModified: Bool {

        trimStart != (session.trimStart ?? fullStart) ||

        trimEnd   != (session.trimEnd   ?? fullEnd)

    }

    init(

        session: ChargeSessionSummary,

        detectedWindow: ChargingWindowDetector.DetectedWindow? = nil,

        liveTimeRange: ClosedRange<Date>? = nil,

        onApply: @escaping (Date?, Date?) -> Void,

        onDismiss: @escaping () -> Void

    ) {

        self.session   = session

        self.liveTimeRange = liveTimeRange

        self.onApply   = onApply

        self.onDismiss = onDismiss

        let fullStart = liveTimeRange?.lowerBound ?? session.startedAt

        let fullEnd = liveTimeRange?.upperBound ?? (session.endedAt ?? session.lastObservedAt)

        let start = session.trimStart

            ?? detectedWindow?.start

            ?? fullStart

        let end = session.trimEnd

            ?? detectedWindow?.end

            ?? fullEnd

        _trimStart = State(initialValue: start)

        _trimEnd   = State(initialValue: end)

    }

    var body: some View {

        VStack(spacing: 0) {

            header

            ScrollView {

                VStack(spacing: 16) {

                    chartWithHandles

                    rangeControls

                    previewMetrics

                    if !checkpointsToRemove.isEmpty {

                        checkpointWarning

                    }

                }

                .padding(16)

            }

            applyBar

        }

        .background(Color(.systemGroupedBackground).ignoresSafeArea())

    }

    // MARK: - Header

    private var header: some View {

        HStack {

            Button("Cancel", action: onDismiss)

                .foregroundColor(.secondary)

            Spacer()

            Text("Trim Session")

                .font(.headline)

            Spacer()

            Button("Reset") {

                withAnimation(.spring(response: 0.3)) {

                    trimStart = fullStart

                    trimEnd   = fullEnd

                }

            }

            .foregroundColor(.orange)

            .disabled(trimStart == fullStart && trimEnd == fullEnd)

        }

        .padding(.horizontal, 18)

        .padding(.vertical, 14)

        .background(.regularMaterial)

    }

    // MARK: - Chart with trim overlay

    private var chartWithHandles: some View {

        VStack(alignment: .leading, spacing: 10) {

            HStack(spacing: 6) {

                Image(systemName: "scissors")

                    .foregroundColor(.blue)

                Text("Session Window")

                    .font(.headline)

            }

            GeometryReader { geo in

                let chartW = geo.size.width

                ZStack(alignment: .topLeading) {

                    // Background chart — full session

                    MeasurementChartView(

                        showsRangeSelector: false,

                        showsTemperatureSeries: false

                    // Dimmed region before trimStart

                    Rectangle()

                        .fill(Color.black.opacity(0.35))

                        .frame(width: max(startFraction * chartW, 0))

                        .allowsHitTesting(false)

                    // Dimmed region after trimEnd

                    let endX = endFraction * chartW

                    Rectangle()

                        .fill(Color.black.opacity(0.35))

                        .frame(width: max(chartW - endX, 0))

                        .offset(x: endX)

                        .allowsHitTesting(false)

                    // Start handle

                    trimHandle(

                        color: .green,

                        symbol: "arrow.right.to.line",

                        xFraction: startFraction,

                        chartWidth: chartW,

                        onDrag: { dx in

                            let newFrac = max(0, min(startFraction + dx / chartW, endFraction - 0.01))

                            trimStart = fullStart.addingTimeInterval(newFrac * sessionDuration)

                        }

                    )

                    // End handle

                    trimHandle(

                        color: .red,

                        symbol: "arrow.left.to.line",

                        xFraction: endFraction,

                        chartWidth: chartW,

                        onDrag: { dx in

                            let newFrac = min(1, max(endFraction + dx / chartW, startFraction + 0.01))

                            trimEnd = fullStart.addingTimeInterval(newFrac * sessionDuration)

                        }

                    )

                }

                .clipped()

            }

            .frame(height: 260)

        }

        .padding(16)

        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

    }

    @ViewBuilder

    private func trimHandle(

        color: Color,

        symbol: String,

        xFraction: Double,

        chartWidth: CGFloat,

        onDrag: @escaping (CGFloat) -> Void

    ) -> some View {

        let xPos = CGFloat(xFraction) * chartWidth

        ZStack(alignment: .top) {

            // Vertical line

            Rectangle()

                .fill(color)

                .frame(width: 2)

                .frame(maxHeight: .infinity)

                .offset(x: xPos - 1)

                .allowsHitTesting(false)

            // Drag knob

            Circle()

                .fill(color)

                .frame(width: 28, height: 28)

                .overlay(

                    Image(systemName: symbol)

                        .font(.system(size: 11, weight: .bold))

                        .foregroundColor(.white)

                )

                .shadow(radius: 3)

                .offset(x: xPos - 14)

                .gesture(

                    DragGesture(minimumDistance: 0, coordinateSpace: .local)

                        .onChanged { value in

                            onDrag(value.translation.width)

                        }

                )

        }

    }

    // MARK: - Range controls

    private var rangeControls: some View {

        VStack(spacing: 12) {

            rangeRow(

                label: "Start",

                color: .green,

                symbol: "arrow.right.to.line",

                date: $trimStart,

                sliderValue: Binding(

                    get: { startFraction },

                    set: { v in

                        let clamped = max(0, min(v, endFraction - 0.01))

                        trimStart = fullStart.addingTimeInterval(clamped * sessionDuration)

                    }

                )

            )

            rangeRow(

                label: "End",

                color: .red,

                symbol: "arrow.left.to.line",

                date: $trimEnd,

                sliderValue: Binding(

                    get: { endFraction },

                    set: { v in

                        let clamped = min(1, max(v, startFraction + 0.01))

                        trimEnd = fullStart.addingTimeInterval(clamped * sessionDuration)

                    }

                )

            )

        }

        .padding(16)

        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

    }

    private func rangeRow(

        label: String,

        color: Color,

        symbol: String,

        date: Binding<Date>,

        sliderValue: Binding<Double>

    ) -> some View {

        VStack(spacing: 6) {

            HStack {

                Image(systemName: symbol)

                    .foregroundColor(color)

                    .frame(width: 20)

                Text(label)

                    .font(.subheadline.weight(.semibold))

                Spacer()

                Text(date.wrappedValue.format())

                    .font(.caption.monospacedDigit())

                    .foregroundColor(.secondary)

            }

            Slider(value: sliderValue, in: 0...1)

                .tint(color)

        }

    }

    // MARK: - Preview metrics

    private var previewMetrics: some View {

        VStack(alignment: .leading, spacing: 12) {

            HStack(spacing: 6) {

                Image(systemName: "waveform.path.ecg")

                    .foregroundColor(.teal)

                Text("Trimmed Metrics")

                    .font(.headline)

            }

            let columns = [GridItem(.flexible()), GridItem(.flexible())]

            LazyVGrid(columns: columns, spacing: 8) {

                previewCell(label: "Energy", value: "\(previewEnergyWh.format(decimalDigits: 3)) Wh", tint: .blue)

                previewCell(label: "Duration", value: formatDuration(trimmedDuration), tint: .teal)

            }

        }

        .padding(16)

        .background(RoundedRectangle(cornerRadius: 14).fill(Color(.secondarySystemGroupedBackground)))

    }

    private func previewCell(label: String, value: String, tint: Color) -> some View {

        VStack(alignment: .leading, spacing: 4) {

            Text(label)

                .font(.caption)

                .foregroundColor(.secondary)

            Text(value)

                .font(.system(.subheadline, design: .rounded).weight(.semibold))

                .foregroundColor(tint)

                .monospacedDigit()

        }

        .frame(maxWidth: .infinity, alignment: .leading)

        .padding(10)

        .background(RoundedRectangle(cornerRadius: 10).fill(tint.opacity(0.10)))

    }

    // MARK: - Checkpoint warning

    private var checkpointWarning: some View {

        HStack(alignment: .top, spacing: 10) {

            Image(systemName: "exclamationmark.triangle.fill")

                .foregroundColor(.orange)

            VStack(alignment: .leading, spacing: 3) {

                Text("\(checkpointsToRemove.count) checkpoint\(checkpointsToRemove.count == 1 ? "" : "s") outside the selected window will be removed.")

                    .font(.subheadline)

                ForEach(checkpointsToRemove) { cp in

                    Text("• \(cp.timestamp.format()) — \(cp.batteryPercent.format(decimalDigits: 0))%")

                        .font(.caption)

                        .foregroundColor(.secondary)

                }

            }

        }

        .padding(14)

        .background(

            RoundedRectangle(cornerRadius: 12)

                .fill(Color.orange.opacity(0.12))

                .overlay(RoundedRectangle(cornerRadius: 12).stroke(Color.orange.opacity(0.25), lineWidth: 1))

        )

    }

    // MARK: - Apply bar

    private var applyBar: some View {

        VStack(spacing: 0) {

            Divider()

            Button {

                let newStart = trimStart == fullStart ? nil : trimStart

                let newEnd   = trimEnd   == fullEnd   ? nil : trimEnd

                onApply(newStart, newEnd)

            } label: {

                Label("Apply Trim", systemImage: "scissors")

                    .font(.body.weight(.semibold))

                    .frame(maxWidth: .infinity)

                    .padding(.vertical, 14)

            }

            .buttonStyle(.borderedProminent)

            .tint(.blue)

            .disabled(!isModified)

            .padding(16)

        }

        .background(.regularMaterial)

    }

    // MARK: - Helpers

    private func formatDuration(_ duration: TimeInterval) -> String {

        let totalSeconds = Int(duration.rounded(.down))

        let hours = totalSeconds / 3600

        let minutes = (totalSeconds % 3600) / 60

        let seconds = totalSeconds % 60

        if hours > 0 { return String(format: "%d:%02d:%02d", hours, minutes, seconds) }

        return String(format: "%02d:%02d", minutes, seconds)

    }

}