import HealthKit

import SQLite3

import XCTest

@testable import HealthProbe

final class SQLiteLargeImportPerformanceTests: XCTestCase {

    private final class AsyncResultBox<T>: @unchecked Sendable {

        var result: Result<T, Error>?

    }

    private var temporaryDirectory: URL!

    override func setUpWithError() throws {

        temporaryDirectory = FileManager.default.temporaryDirectory

            .appending(path: "HealthProbeLargeImportTests-\(UUID().uuidString)", directoryHint: .isDirectory)

        try FileManager.default.createDirectory(at: temporaryDirectory, withIntermediateDirectories: true)

    }

    override func tearDownWithError() throws {

        if let temporaryDirectory {

            try? FileManager.default.removeItem(at: temporaryDirectory)

        }

        temporaryDirectory = nil

    }

    func testLargeSyntheticFullImportSmoke() throws {

        let definitions = syntheticImportDefinitions()

        let samples = makeSyntheticImportSamples(totalCount: 5_000, definitions: definitions)

        let url = databaseURL(named: "LargeImportSmoke-\(UUID().uuidString).sqlite")

        try runSyntheticImport(

            samples: samples,

            definitions: definitions,

            databaseURL: url

        )

    }

    func testLargeSyntheticFullImportBenchmark() throws {

        let environment = ProcessInfo.processInfo.environment

        let defaults = UserDefaults.standard

        let isEnabled = environment["HP_ENABLE_LARGE_IMPORT_BENCHMARK"] == "1"

            || defaults.bool(forKey: "HP_ENABLE_LARGE_IMPORT_BENCHMARK")

        guard isEnabled else {

            throw XCTSkip("""

            Large import benchmark is opt-in. Run with environment variable \

            HP_ENABLE_LARGE_IMPORT_BENCHMARK=1 or launch argument \

            -HP_ENABLE_LARGE_IMPORT_BENCHMARK YES, plus optional \

            HP_LARGE_IMPORT_SAMPLE_COUNT / HP_LARGE_IMPORT_ITERATIONS overrides.

            """)

        }

        let sampleCount = max(

            1_000,

            Int(environment["HP_LARGE_IMPORT_SAMPLE_COUNT"] ?? "")

                ?? defaults.integer(forKey: "HP_LARGE_IMPORT_SAMPLE_COUNT").nonZero

                ?? 250_000

        )

        let iterationCount = max(

            1,

            Int(environment["HP_LARGE_IMPORT_ITERATIONS"] ?? "")

                ?? defaults.integer(forKey: "HP_LARGE_IMPORT_ITERATIONS").nonZero

                ?? 1

        )

        let definitions = syntheticImportDefinitions()

        let samples = makeSyntheticImportSamples(totalCount: sampleCount, definitions: definitions)

        let options = XCTMeasureOptions()

        options.iterationCount = iterationCount

        measure(metrics: [XCTClockMetric(), XCTMemoryMetric()], options: options) {

            let url = databaseURL(named: "LargeImport-\(UUID().uuidString).sqlite")

            do {

                try runSyntheticImport(

                    samples: samples,

                    definitions: definitions,

                    databaseURL: url

                )

            } catch {

                XCTFail("Large synthetic import benchmark failed: \(error)")

            }

        }

    }

    private func databaseURL(named name: String) -> URL {

        temporaryDirectory.appending(path: name)

    }

    private func syntheticImportDefinitions() -> [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)] {

        [

            (HKQuantityType.quantityType(forIdentifier: .heartRate)!, HKUnit.count().unitDivided(by: .minute()), 55),

            (HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!, .kilocalorie(), 1.5),

            (HKQuantityType.quantityType(forIdentifier: .basalEnergyBurned)!, .kilocalorie(), 1.1),

            (HKQuantityType.quantityType(forIdentifier: .stepCount)!, .count(), 12),

            (HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)!, .meter(), 8)

        ]

    }

    private func makeSyntheticImportSamples(

        totalCount: Int,

        definitions: [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)]

    ) -> [HKQuantitySample] {

        return (0..<totalCount).map { index in

            let definition = definitions[index % definitions.count]

            let value = definition.baseline + Double(index % 17)

            let start = Date(timeIntervalSince1970: 10_000 + Double(index * 60))

            let end = start.addingTimeInterval(definition.sampleType.identifier == HKQuantityTypeIdentifier.heartRate.rawValue ? 5 : 60)

            let quantity = HKQuantity(unit: definition.unit, doubleValue: value)

            return HKQuantitySample(type: definition.sampleType, quantity: quantity, start: start, end: end)

        }

    }

    private func runSyntheticImport(

        samples: [HKQuantitySample],

        definitions: [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)],

        databaseURL url: URL

    ) throws {

        let store = SQLiteHealthArchiveStore(databaseURL: url)

        let observedAt = Date(timeIntervalSince1970: 5_000_000)

        defer {

            try? FileManager.default.removeItem(at: url)

            try? FileManager.default.removeItem(at: URL(fileURLWithPath: url.path + "-shm"))

            try? FileManager.default.removeItem(at: URL(fileURLWithPath: url.path + "-wal"))

        }

        try waitForArchiveOperation {

            let observationID = try await store.beginObservation(

                observedAt: observedAt,

                triggerReason: "benchmarkLargeSyntheticImport",

                selectedTypeSetHash: "synthetic-large-import"

            )

            _ = try await store.upsertSamples(

                samples,

                observedAt: observedAt,

                observationID: observationID

            )

            for definition in definitions {

                _ = try await store.markVerification(

                    sampleType: definition.sampleType,

                    verifiedAt: observedAt,

                    observationID: observationID

                )

            }

            try await store.finishObservation(

                observationID: observationID,

                status: "completed",

                endedAt: observedAt.addingTimeInterval(1)

            )

            return ()

        }

        XCTAssertEqual(try countRows(in: "samples", at: url), samples.count)

        XCTAssertEqual(try countRows(in: "sample_versions", at: url), samples.count)

        XCTAssertEqual(try countRows(in: "observation_type_runs", at: url), definitions.count)

    }

    private func waitForArchiveOperation<T>(_ operation: @escaping () async throws -> T) throws -> T {

        let expectation = expectation(description: "archive operation")

        let box = AsyncResultBox<T>()

        Task {

            do {

                box.result = .success(try await operation())

            } catch {

                box.result = .failure(error)

            }

            expectation.fulfill()

        }

        wait(for: [expectation], timeout: 120)

        return try XCTUnwrap(box.result).get()

    }

    private func countRows(in tableName: String, at url: URL) throws -> Int {

        var db: OpaquePointer?

        guard sqlite3_open_v2(url.path, &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nil) == SQLITE_OK else {

            sqlite3_close(db)

            XCTFail("Could not open benchmark database")

            return 0

        }

        defer { sqlite3_close(db) }

        var statement: OpaquePointer?

        guard sqlite3_prepare_v2(db, "SELECT COUNT(*) FROM \(tableName)", -1, &statement, nil) == SQLITE_OK else {

            sqlite3_finalize(statement)

            XCTFail("Could not prepare benchmark count query")

            return 0

        }

        defer { sqlite3_finalize(statement) }

        guard sqlite3_step(statement) == SQLITE_ROW else {

            return 0

        }

        return Int(sqlite3_column_int(statement, 0))

    }

}

private extension Int {

    var nonZero: Int? {

        self == 0 ? nil : self

    }

}