import Foundation

@main
struct MiruroMetadataChecks {
    struct Failure: Error { let message: String }
    struct Promise { let id: Int }
    static let mediaID = "OERe_a0YS4h-DlsBDOeXwX7HOO6316tw"
    static let canonical = "/watch/\(mediaID)/the-apothecary-diaries-season-3?ep=1"

    static func require(_ condition: @autoclosure () -> Bool, _ message: String) throws {
        if !condition() { throw Failure(message: message) }
    }

    static func reject(_ message: String, _ operation: () throws -> Void) throws {
        do { try operation() }
        catch {
            try require(!error.localizedDescription.contains("secret"), "errors do not expose untrusted URLs")
            return
        }
        throw Failure(message: "Accepted \(message)")
    }

    // Sanitized observed watch schema; every envelope deliberately owns a fresh devalue table.
    static func table(_ root: Any) -> [Any] {
        var result: [Any] = []
        func append(_ value: Any) -> Int {
            let index = result.count
            result.append(NSNull())
            if let promise = value as? Promise {
                let reference = append(promise.id)
                result[index] = ["Promise", reference] as [Any]
            } else if let object = value as? [String: Any] {
                var references: [String: Int] = [:]
                for key in object.keys.sorted() { references[key] = append(object[key]!) }
                result[index] = references
            } else if let array = value as? [Any] {
                let references = array.map { append($0) }
                result[index] = references
            } else {
                result[index] = value
            }
            return index
        }
        _ = append(root)
        return result
    }

    static func wire(_ envelopes: [[String: Any]]) throws -> Data {
        var body = Data()
        for envelope in envelopes {
            body.append(try JSONSerialization.data(withJSONObject: envelope, options: [.sortedKeys]))
            body.append(10)
        }
        return body
    }

    static func initial(media: Any = ["id": mediaID, "title": ["english": "The Apothecary Diaries Season 3"]],
                        episodes: Any = Promise(id: 23)) -> [String: Any] {
        ["type": "data", "nodes": [NSNull(), ["type": "data", "data": table([
            "media": media, "episodeNumber": 1, "episodesData": episodes,
            "sourcesData": Promise(id: 99), "seasonsData": Promise(id: 8)
        ])]]]
    }

    static func chunk(_ payload: Any, id: Int = 23) -> [String: Any] {
        ["type": "chunk", "id": id, "data": table(payload)]
    }

    static var rows: [[String: Any]] { [
        ["episode": 1, "type": "op", "start": 63.313, "end": 153.237],
        ["episode": 1, "type": "ed", "start": 1335.252, "end": 1425.384]
    ] }

    static func payload(_ intervals: Any = rows) -> [String: Any] {
        ["currentEpisode": ["number": 1, "title": "Locusts"],
         "episodes": [["number": 2, "title": "Not selected"]], "aniskip": intervals]
    }

    static func decode(_ envelopes: [[String: Any]]) throws -> MiruroMetadata {
        try MiruroMetadataResolver.decode(wire(envelopes), mediaID: mediaID, episode: 1)
    }

    static func checks() async throws {
        let unrelated: [String: Any] = ["type": "chunk", "id": 99,
            "data": [["streams": 1], ["UnsupportedSourceTag", 999999]]]
        let fixtures = [initial(), chunk(payload()), unrelated, chunk(["ignored": "season"], id: 8)]
        let metadata = try decode(fixtures)
        try require(metadata.title == "The Apothecary Diaries Season 3 — Episode 1: Locusts", "descriptive media and selected episode title")
        try require(metadata.intervals.count == 2, "observed fractional opening and ending decoded")
        try require(metadata.intervals[0].start == 63.313 && metadata.intervals[1].end == 1425.384, "fractional seconds preserved")
        try require(metadata.intervals.allSatisfy { $0.votes == nil && $0.provider == nil && $0.referenceLength == nil }, "absent provenance is not invented")
        let reordered = try decode([unrelated, chunk(payload()), initial()])
        try require(reordered.title == metadata.title && reordered.intervals == metadata.intervals, "independent and out-of-order promise IDs")
        let inline = try decode([initial(episodes: payload())])
        try require(inline.intervals == metadata.intervals, "inline episode metadata")
        let titleOnly = try decode([initial()])
        try require(titleOnly.title == "The Apothecary Diaries Season 3 — Episode 1" && titleOnly.intervals.isEmpty, "unresolved optional episode promise preserves series title")
        let rejected = try decode([initial(), ["type": "chunk", "id": 23, "error": ["message": "secret"]]])
        try require(rejected.title == titleOnly.title && rejected.intervals.isEmpty, "rejected episode promise preserves title")
        let duplicated = try decode([initial(), chunk(payload()), chunk(payload())])
        try require(duplicated.title == titleOnly.title && duplicated.intervals.isEmpty, "ambiguous duplicate promise is not selected")
        let segmentsOnly = try decode([initial(media: NSNull()), chunk(["aniskip": rows])])
        try require(segmentsOnly.title == nil && segmentsOnly.intervals.count == 2, "interval enrichment does not require title")
        let episodeOnly = try decode([initial(media: NSNull()), chunk(payload())])
        try require(episodeOnly.title == "Episode 1: Locusts", "episode title without media title")
        let fallbackTitle = try decode([initial(media: ["title": ["english": " ", "romaji": "Kusuriya"]]), chunk(payload())])
        try require(fallbackTitle.title?.hasPrefix("Kusuriya —") == true, "title language fallback")
        let selected = try decode([initial(), chunk(["currentEpisode": ["number": 2, "title": "Wrong"],
            "episodes": [["number": 2, "title": "Wrong"], ["number": 1, "title": "Correct"]]])])
        try require(selected.title?.hasSuffix(": Correct") == true, "episode titles are selected by returned number")
        let mixedRows: [Any] = [NSNull(), "bad", ["episode": 1, "type": "op", "start": "bad", "end": 100],
            ["episode": true, "type": "op", "start": 0, "end": 100],
            ["episode": 1, "type": "recap", "start": 0, "end": 100]] + rows
        let partial = try decode([initial(), chunk(payload(mixedRows))])
        try require(partial.title == metadata.title && partial.intervals == metadata.intervals, "malformed rows and unknown kinds do not poison usable metadata")
        try reject("wrong returned media identity") {
            _ = try decode([initial(media: ["id": "different", "title": "Wrong"]), chunk(payload())])
        }
        try reject("oversized body") {
            _ = try MiruroMetadataResolver.decode(Data(repeating: 32, count: MiruroMetadataResolver.bodyLimit + 1), mediaID: mediaID, episode: 1)
        }
        try reject("deep JSON") {
            _ = try MiruroMetadataResolver.decode(Data((String(repeating: "[", count: 65) + "0" + String(repeating: "]", count: 65)).utf8), mediaID: mediaID, episode: 1)
        }
        try reject("malformed JSON") {
            _ = try MiruroMetadataResolver.decode(Data("{broken".utf8), mediaID: mediaID, episode: 1)
        }
        let cycle: [String: Any] = ["type": "chunk", "id": 23, "data": [["Promise", 1], 23]]
        let cyclic = try decode([initial(), cycle])
        try require(cyclic.title == titleOnly.title && cyclic.intervals.isEmpty, "promise cycles are depth bounded and optional")
        let amplified: [String: Any] = ["type": "chunk", "id": 23,
            "data": [["aniskip": 1], Array(repeating: 2, count: 70000), ["type": 3], "op"]]
        let bounded = try decode([initial(), amplified])
        try require(bounded.title == titleOnly.title && bounded.intervals.isEmpty, "repeated-reference expansion is bounded")

        try normalizationChecks()
        try redirectChecks()
        let responseURL = URL(string: "https://barelystarted.miruro.tv\(canonical)")!
        for mime in ["application/json", "text/sveltekit-data"] {
            try MiruroMetadataResolver.validateResponse(HTTPURLResponse(url: responseURL, statusCode: 200,
                httpVersion: nil, headerFields: ["Content-Type": mime])!)
        }
        for (status, type, size) in [(403, "text/html", "12"), (302, "application/json", "12"),
                                    (200, "text/html", "12"), (200, "application/json", "2097153")] {
            try reject("protection, redirect or oversized response") {
                try MiruroMetadataResolver.validateResponse(HTTPURLResponse(url: responseURL, statusCode: status,
                    httpVersion: nil, headerFields: ["Content-Type": type, "Content-Length": size])!)
            }
        }
        let cancelled = Task {
            withUnsafeCurrentTask { $0?.cancel() }
            return try await MiruroMetadataResolver.resolve(mediaID: mediaID, episode: 1)
        }
        do { _ = try await cancelled.value; throw Failure(message: "Cancellation accepted") }
        catch is CancellationError {}
        print("PASS: native optional metadata protocol, independent promises, safe redirects, bounded decoding and interval normalization")
    }

    static func normalizationChecks() throws {
        func interval(_ kind: MiruroInterval.Kind = .intro, _ start: Double = 0, _ end: Double = 10,
                      episode: Int = 1, votes: Double? = nil, provider: String? = nil,
                      length: Double? = nil) -> MiruroInterval {
            MiruroInterval(kind: kind, start: start, end: end, episode: episode,
                provider: provider, votes: votes, referenceLength: length)
        }
        let valid = interval(.intro, 10, 100)
        for duration in [0, -1, Double.nan, .infinity] {
            try require(MiruroMetadata(title: nil, intervals: [valid]).visibleIntervals(episode: 1, duration: duration).isEmpty, "wait for finite positive actual duration")
        }
        let invalid = [interval(.intro, -10, 0), interval(.intro, 100, 110),
            interval(.intro, 10, 10), interval(.intro, 20, 10),
            interval(.intro, .nan, 10), interval(.intro, 0, .infinity),
            interval(episode: 2), interval(votes: -1), interval(votes: .nan),
            interval(provider: "SomeCrunchyrollProvider"), interval(length: 106)]
        try require(MiruroMetadata(title: nil, intervals: invalid).visibleIntervals(episode: 1, duration: 100).isEmpty, "bounds, episode, votes, provenance and reference-length rejection")
        let metadata = MiruroMetadata(title: nil, intervals: [valid])
        try require(metadata.visibleIntervals(episode: 1, duration: 100) == [valid], "end equal to duration allowed")
        try require(metadata.visibleIntervals(episode: 1, duration: 99) == [interval(.intro, 10, 99)], "duration shrink clips the visible interval")
        try require(metadata.visibleIntervals(episode: 1, duration: 120) == [valid] && metadata.intervals == [valid], "duration growth restores unchanged raw timestamps")
        let overlapping = MiruroMetadata(title: nil, intervals: [
            interval(.intro, -5.5, 10.25), interval(.outro, 90.75, 110.5)])
        try require(overlapping.visibleIntervals(episode: 1, duration: 100) == [
            interval(.intro, 0, 10.25), interval(.outro, 90.75, 100)], "partial overlaps clip at both playback boundaries")
        try require(overlapping.visibleIntervals(episode: 1, duration: 120) == [
            interval(.intro, 0, 10.25), interval(.outro, 90.75, 110.5)], "growth recomputes clipping from raw timestamps")
        try require(MiruroMetadata(title: nil, intervals: [interval(.intro, -10, 110)])
            .visibleIntervals(episode: 1, duration: 100) == [interval(.intro, 0, 100)], "interval spanning the video clips to the playable range")
        let first = interval(.intro, 5, 15, votes: 4), tied = interval(.intro, 20, 30, votes: 4)
        let ending = interval(.outro, 12, 40, votes: 2)
        let ranked = MiruroMetadata(title: nil, intervals: [interval(), first, tied, ending, interval(.outro, 50, 60, votes: 1)])
        try require(ranked.visibleIntervals(episode: 1, duration: 100) == [first, ending], "descending votes, stable ties, intro then outro, no merging overlap")
        let optional = [interval(length: 105), interval(.outro, 80, 100, length: 0)]
        try require(MiruroMetadata(title: nil, intervals: optional).visibleIntervals(episode: 1, duration: 100) == optional, "five-percent equality and absent/nonpositive length handling")
        let raw = try decode([initial(), chunk(payload([
            ["episode": 1, "type": "mixed-op", "start": 1, "end": 10, "votes": 3, "provider": "aniskip", "episode_length": 100],
            ["episode": 1, "type": "mixed-ed", "start": 90, "end": 100]
        ]))])
        try require(raw.intervals.count == 2 && raw.intervals[0].rawKind == "mixed-op" && raw.intervals[0].votes == 3 && raw.intervals[0].provider == "aniskip" && raw.intervals[0].referenceLength == 100, "evidenced mixed kinds and optional fields preserved")
    }

    static func redirectChecks() throws {
        let envelope = try wire([["type": "redirect", "location": canonical]])
        guard case .redirect(let location) = try MiruroMetadataResolver.decodeRoute(envelope, mediaID: mediaID, episode: 1) else {
            throw Failure(message: "HTTP-200 route redirect not recognized")
        }
        var route = try MiruroMetadataResolver.Route(mediaID: mediaID, episode: 1)
        try require(route.url.path.hasSuffix("/episode/__data.json"), "placeholder data route")
        try route.follow(location)
        try require(route.url.path.hasSuffix("/the-apothecary-diaries-season-3/__data.json") && route.url.query == "ep=1", "canonical data route preserves episode")
        try reject("redirect loop") { try route.follow(canonical) }
        for unsafe in ["https://evil.example\(canonical)", "//evil.example\(canonical)",
            "http://barelystarted.miruro.tv\(canonical)", "https://user:secret@barelystarted.miruro.tv\(canonical)",
            canonical.replacingOccurrences(of: mediaID, with: "other"), canonical.replacingOccurrences(of: "ep=1", with: "ep=2"),
            canonical + "&ep=1", canonical + "#secret", canonical.replacingOccurrences(of: "ep=1", with: "ep=%31"),
            canonical.replacingOccurrences(of: "/watch/", with: "/info/"), "/", canonical + "\n",
            canonical.replacingOccurrences(of: "/the-apothecary", with: "/%74he-apothecary")] {
            try reject("unsafe canonical redirect") {
                var route = try MiruroMetadataResolver.Route(mediaID: mediaID, episode: 1)
                try route.follow(unsafe)
            }
        }
        var bounded = try MiruroMetadataResolver.Route(mediaID: mediaID, episode: 1)
        for index in 0..<MiruroMetadataResolver.redirectLimit { try bounded.follow("/watch/\(mediaID)/slug-\(index)?ep=1") }
        try reject("too many redirects") { try bounded.follow("/watch/\(mediaID)/last?ep=1") }
    }

    static func main() async {
        do {
            let args = Array(CommandLine.arguments.dropFirst())
            if args.count == 2, args[0] == "--live" {
                guard case .miruro(let id, let episode) = try StreamURL.parse(args[1]) else {
                    throw Failure(message: "--live requires a Miruro episode URL")
                }
                let metadata = try await MiruroMetadataResolver.resolve(mediaID: id, episode: episode)
                // JSON escaping prevents terminal control injection; source payloads/URLs are never printed.
                let projection: [String: Any] = ["title": metadata.title as Any? ?? NSNull(),
                    "intervals": metadata.intervals.map { row -> [String: Any] in
                        ["kind": row.kind == .intro ? "intro" : "outro", "episode": row.episode, "start": row.start, "end": row.end]
                    }]
                let data = try JSONSerialization.data(withJSONObject: projection, options: [.sortedKeys])
                print(String(decoding: data, as: UTF8.self))
            } else if args.isEmpty {
                try await checks()
            } else {
                throw Failure(message: "Usage: miruro-metadata-check [--live EPISODE_URL]")
            }
        } catch {
            let message = (error as? Failure)?.message ?? "Miruro optional metadata check failed."
            FileHandle.standardError.write(Data("FAIL: \(message)\n".utf8))
            exit(1)
        }
    }
}