import Foundation

func values(_ input: String) -> [String: String] {
    var result: [String: String] = [:]
    for item in input.split(separator: ";") {
        let pair = item.split(separator: "=", maxSplits: 1).map(String.init)
        if pair.count == 2 { result[pair[0]] = pair[1] }
    }
    return result
}

func evaluate(_ kind: String, _ input: String) -> String {
    let values = values(input)
    switch kind {
    case "version": return ["1", "0", "-1"].contains(input) ? "valid" : "invalid:unsupported_version"
    case "page":
        guard let raw = values["limit"], let limit = Int(raw), (1...100).contains(limit) else { return "invalid:invalid_limit" }
        return "valid"
    case "manifest":
        for key in ["provider_url", "vm_address", "password", "private_key"] where values[key] != nil { return "invalid:forbidden_field" }
        return values["version"] == "1" && values["gateway_id"] != nil && (values["grant"]?.utf8.count ?? 0) >= 43 && values["purpose"] == "launch" ? "valid" : "invalid:invalid_manifest"
    case "clipboard": return values["encoding"] == "utf-8" && values["file"] == nil ? "valid" : "invalid:unsupported_clipboard"
    case "event":
        guard values["version"] == "1" else { return "invalid:unsupported_version" }
        if let after = Int(values["after"] ?? ""), let earliest = Int(values["earliest"] ?? ""), after > 0, earliest > 0, after < earliest - 1 { return "invalid:gap" }
        if (Int(values["payload_bytes"] ?? "") ?? Int.max) > 16384 { return "invalid:payload_limit" }
        guard let sequence = Int(values["sequence"] ?? ""), sequence > 0, values["correlation_id"] != nil else { return "invalid:required" }
        return "valid"
    case "tunnel":
        if ["1", "0", "-1"].contains(values["offered"] ?? "") && values["feature"] == "control.v1" { return "valid" }
        return values["feature"] == "control.v1" ? "invalid:unsupported_version" : "invalid:unsupported_feature"
    case "datagram": return classifyDatagram(values["hex"] ?? "")
    default: return "invalid:unknown_kind"
    }
}

func classifyDatagram(_ encoded: String) -> String {
    let characters = Array(encoded)
    guard characters.count % 2 == 0 else { return "invalid:hex" }
    var raw: [UInt8] = []
    for index in stride(from: 0, to: characters.count, by: 2) {
        guard let byte = UInt8(String(characters[index...index + 1]), radix: 16) else { return "invalid:hex" }
        raw.append(byte)
    }
    guard raw.count >= 21 else { return "invalid:truncated" }
    guard raw[0] == 0x56 && raw[1] == 0x44 else { return "invalid:magic" }
    guard raw[2] == 1 else { return "invalid:unsupported_version" }
    let limit: Int
    switch raw[3] {
    case 1: limit = 1024
    case 2: limit = 2048
    case 3: limit = 65515
    case 10, 11, 12: limit = 1179
    default: return "invalid:unknown_channel"
    }
    guard raw[4] == 0 else { return "invalid:flags" }
    guard raw[18] > 0 && raw[17] < raw[18] else { return "invalid:fragment" }
    let payloadLength = Int(raw[19]) * 256 + Int(raw[20])
    guard payloadLength <= limit else { return "invalid:payload_limit" }
    guard raw.count == 21 + payloadLength else { return "invalid:length_mismatch" }
    guard raw.count <= 65536 else { return "invalid:frame_limit" }
    return "valid"
}

func normalizedDigest(_ results: [String]) -> String {
    var value: UInt64 = 14695981039346656037
    for result in results {
        for byte in Array("\(result)\n".utf8) {
            value ^= UInt64(byte)
            value = value &* 1099511628211
        }
    }
    return String(format: "%016llx", value)
}

func fixtureHash() -> String {
    let text = try! String(contentsOfFile: "fixtures/manifest.json", encoding: .utf8)
    let marker = "\"corpus_sha256\": \""
    guard let start = text.range(of: marker)?.upperBound else { fatalError("fixture hash") }
    let suffix = text[start...]
    guard let end = suffix.firstIndex(of: "\"") else { fatalError("fixture hash") }
    return String(suffix[..<end])
}

@main
struct ConformanceMain {
    static func main() {
        let names = try! FileManager.default.contentsOfDirectory(atPath: "fixtures/conformance").filter { $0.hasSuffix(".tsv") }.sorted()
        var results: [String] = []
        for name in names {
            let text = try! String(contentsOfFile: "fixtures/conformance/\(name)", encoding: .utf8)
            var lines = text.split(whereSeparator: \.isNewline).map(String.init)
            precondition(lines.removeFirst() == "id\tversion\tkind\tinput\texpected")
            for line in lines {
                let fields = line.split(separator: "\t", omittingEmptySubsequences: false).map(String.init)
                precondition(fields.count == 5)
                let actual = evaluate(fields[2], fields[3])
                precondition(actual == fields[4], fields[0])
                results.append("\(fields[0])\t\(actual)")
            }
        }
        print("Swift conformance passed normalized=\(normalizedDigest(results)) fixtures=\(fixtureHash())")
    }
}