import Foundation

extension CostUsageScanner {
    static func extractJSONByteStringField(
        _ field: [UInt8],
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>,
        atDepth targetDepth: Int) -> String?
    {
        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
            guard let parsed = parseJSONByteStringRange(in: bytes, index: &valueIndex, limit: range.upperBound),
                  parsed.range.lowerBound < parsed.range.upperBound
            else { return nil }
            if parsed.hasEscapes {
                return self.decodeEscapedJSONByteString(from: bytes, in: parsed.range)
            }
            return String(bytes: bytes[parsed.range], encoding: .utf8)
        }
    }

    static func extractJSONByteObjectField(
        _ field: [UInt8],
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>,
        atDepth targetDepth: Int) -> Range<Int>?
    {
        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
            self.parseJSONByteObjectRange(in: bytes, index: &valueIndex, limit: range.upperBound)
        }
    }

    static func extractJSONByteIntField(
        _ field: [UInt8],
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>,
        atDepth targetDepth: Int) -> Int?
    {
        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
            self.parseJSONByteInt(in: bytes, index: &valueIndex, limit: range.upperBound)
        }
    }

    private static func extractJSONByteField<T>(
        _ field: [UInt8],
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>,
        atDepth targetDepth: Int,
        parseValue: (inout Int) -> T?) -> T?
    {
        var index = range.lowerBound
        var depth = 0

        while index < range.upperBound {
            switch bytes[index] {
            case 0x7B: // {
                depth += 1
                index += 1
            case 0x7D: // }
                depth -= 1
                index += 1
            case 0x22: // "
                var valueIndex = index
                guard let key = parseJSONByteStringRange(in: bytes, index: &valueIndex, limit: range.upperBound)
                else { return nil }
                index = valueIndex
                guard depth == targetDepth,
                      !key.hasEscapes,
                      self.byteRange(bytes, key.range, equals: field)
                else { continue }

                self.skipJSONByteWhitespace(in: bytes, index: &valueIndex, limit: range.upperBound)
                guard valueIndex < range.upperBound, bytes[valueIndex] == 0x3A else { continue } // :

                valueIndex += 1
                self.skipJSONByteWhitespace(in: bytes, index: &valueIndex, limit: range.upperBound)
                if let value = parseValue(&valueIndex) {
                    return value
                }
            default:
                index += 1
            }
        }

        return nil
    }

    private static func parseJSONByteStringRange(
        in bytes: UnsafeBufferPointer<UInt8>,
        index: inout Int,
        limit: Int) -> (range: Range<Int>, hasEscapes: Bool)?
    {
        guard index < limit, bytes[index] == 0x22 else { return nil } // "
        index += 1
        let start = index
        var hasEscapes = false

        while index < limit {
            switch bytes[index] {
            case 0x5C: // \
                hasEscapes = true
                index += 2
            case 0x22: // "
                let end = index
                index += 1
                return (start..<end, hasEscapes)
            default:
                index += 1
            }
        }

        return nil
    }

    private static func parseJSONByteObjectRange(
        in bytes: UnsafeBufferPointer<UInt8>,
        index: inout Int,
        limit: Int) -> Range<Int>?
    {
        guard index < limit, bytes[index] == 0x7B else { return nil } // {
        let start = index
        var depth = 0

        while index < limit {
            switch bytes[index] {
            case 0x22: // "
                guard self.parseJSONByteStringRange(in: bytes, index: &index, limit: limit) != nil else {
                    return nil
                }
            case 0x7B: // {
                depth += 1
                index += 1
            case 0x7D: // }
                depth -= 1
                index += 1
                if depth == 0 {
                    return start..<index
                }
            default:
                index += 1
            }
        }

        return nil
    }

    private static func parseJSONByteInt(
        in bytes: UnsafeBufferPointer<UInt8>,
        index: inout Int,
        limit: Int) -> Int?
    {
        var sign = 1
        if index < limit, bytes[index] == 0x2D { // -
            sign = -1
            index += 1
        }

        var value = 0
        var sawDigit = false
        while index < limit {
            let byte = bytes[index]
            guard byte >= 0x30, byte <= 0x39 else { break }
            sawDigit = true
            let digit = Int(byte - 0x30)
            let multiplied = value.multipliedReportingOverflow(by: 10)
            if multiplied.overflow { return nil }
            let added = multiplied.partialValue.addingReportingOverflow(digit)
            if added.overflow { return nil }
            value = added.partialValue
            index += 1
        }
        return sawDigit ? (sign == -1 ? -value : value) : nil
    }

    private static func skipJSONByteWhitespace(
        in bytes: UnsafeBufferPointer<UInt8>,
        index: inout Int,
        limit: Int)
    {
        while index < limit {
            switch bytes[index] {
            case 0x20, 0x09, 0x0A, 0x0D:
                index += 1
            default:
                return
            }
        }
    }

    private static func decodeEscapedJSONByteString(
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>) -> String?
    {
        var out: [UInt8] = []
        out.reserveCapacity(range.count)
        var index = range.lowerBound
        while index < range.upperBound {
            let byte = bytes[index]
            guard byte == 0x5C else { // \
                out.append(byte)
                index += 1
                continue
            }

            index += 1
            guard index < range.upperBound else { return nil }
            switch bytes[index] {
            case 0x22, 0x5C, 0x2F: // ", \, /
                out.append(bytes[index])
            case 0x62: // b
                out.append(0x08)
            case 0x66: // f
                out.append(0x0C)
            case 0x6E: // n
                out.append(0x0A)
            case 0x72: // r
                out.append(0x0D)
            case 0x74: // t
                out.append(0x09)
            case 0x75: // u
                return self.decodeJSONStringViaFoundation(from: bytes, in: range)
            default:
                return nil
            }
            index += 1
        }

        return String(bytes: out, encoding: .utf8)
    }

    private static func decodeJSONStringViaFoundation(
        from bytes: UnsafeBufferPointer<UInt8>,
        in range: Range<Int>) -> String?
    {
        var data = Data([0x22])
        data.append(UnsafeBufferPointer(rebasing: bytes[range]))
        data.append(0x22)
        return (try? JSONSerialization.jsonObject(with: data)) as? String
    }

    private static func byteRange(
        _ bytes: UnsafeBufferPointer<UInt8>,
        _ range: Range<Int>,
        equals field: [UInt8]) -> Bool
    {
        guard range.count == field.count else { return false }
        var index = range.lowerBound
        var fieldIndex = 0
        while index < range.upperBound {
            guard bytes[index] == field[fieldIndex] else { return false }
            index += 1
            fieldIndex += 1
        }
        return true
    }
}