SWCompression/Sources/ZIP/LittleEndianByteReader+Zip.swift

// Copyright (c) 2026 Timofey Solomko
// Licensed under MIT License
//
// See LICENSE for license information

import Foundation
import BitByteData

extension LittleEndianByteReader {

    func zipString(_ length: Int, _ useUtf8: Bool) -> String? {
        guard length > 0
            else { return "" }
        let stringData = self.data[self.offset..<self.offset + length]
        self.offset += length
        if useUtf8 {
            return String(data: stringData, encoding: .utf8)
        }
        if String.cp437Available && !stringData.needsUtf8() {
            #if (os(Linux) || os(Windows)) && (compiler(<6.2))
                return stringData.decodeCp437()
            #else
                return String(data: stringData, encoding: String.cp437Encoding)
            #endif

        } else {
            return String(data: stringData, encoding: .utf8)
        }
    }

}

fileprivate extension String {

    // "Latin-US (DOS)" CP437-2147483120
    // Note that this encoding is interpreted differently "depending on the context". This concerns codes in 0-31 range
    // and code 127: sometimes they are treated as normal characters (as was defined by IBM) and sometimes as control
    // characters, matching corresponding ranges of ASCII/UTF-8. The second interpretation, however, doesn't make CP437
    // compatible with UTF-8, as CP437 contains codes in the 80-FF range which are not valid UTF-8 codes.
    // In any case, we are constrained to the implementation provided by Foundation, which currently treats them as
    // control characters.
    #if (os(Linux) || os(Windows)) && (compiler(<6.2))
        /// CP437 is available on all platforms where decoding is performed manually.
        static let cp437Available = true
        static let cp437UnicodeScalars = [0x0000, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 0x25D8, 0x25CB,
                                          0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C, 0x25BA, 0x25C4, 0x2195, 0x203C,
                                          0x00B6, 0x00A7, 0x25AC, 0x21A8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194,
                                          0x25B2, 0x25BC, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
                                          0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031,
                                          0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B,
                                          0x003C, 0x003D, 0x003E, 0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,
                                          0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
                                          0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
                                          0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0062, 0x0063,
                                          0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D,
                                          0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
                                          0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x2302, 0x00C7, 0x00FC,
                                          0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF,
                                          0x00EE, 0x00EC, 0x00C4, 0x00C5, 0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2,
                                          0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
                                          0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310,
                                          0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB, 0x2591, 0x2592, 0x2593, 0x2502,
                                          0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C,
                                          0x255B, 0x2510, 0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
                                          0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567, 0x2568, 0x2564,
                                          0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588,
                                          0x2584, 0x258C, 0x2590, 0x2580, 0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3,
                                          0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
                                          0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219,
                                          0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0].map { UnicodeScalar($0)! }
    #else
        static let cp437Available = String.availableStringEncodings.contains(cp437Encoding)
        static let cp437Encoding = String.Encoding(rawValue: 0x80000400)
    #endif

}

fileprivate extension Data {

    #if (os(Linux) || os(Windows)) && (compiler(<6.2))
        func decodeCp437() -> String {
            var out = ""
            out.unicodeScalars.append(contentsOf: self.toByteArray().map { String.cp437UnicodeScalars[$0.toInt()] })
            return out
        }
    #endif

    func needsUtf8() -> Bool {
        // UTF-8 can have BOM.
        if self.count >= 3 {
            if self[self.startIndex] == 0xEF && self[self.startIndex + 1] == 0xBB && self[self.startIndex + 2] == 0xBF {
                return true
            }
        }

        var index = self.startIndex
        while index < self.endIndex {
            let byte = self[index]
            if byte <= 0x7F { // This simple byte can exist both in CP437 and UTF-8.
                index += 1
                continue
            }

            // Otherwise, it has to be correct code sequence in case of UTF-8.
            // If code sequence is incorrect, then it is CP437.
            let codeLength: Int
            if byte >= 0xC2 && byte <= 0xDF {
                codeLength = 2
            } else if byte >= 0xE0 && byte <= 0xEF {
                codeLength = 3
            } else if byte >= 0xF0 && byte <= 0xF4 {
                codeLength = 4
            } else {
                return false
            }

            if index + codeLength - 1 >= self.endIndex {
                return false
            }

            for i in 1..<codeLength {
                if self[index + i] & 0xC0 != 0x80 {
                    return false
                }
            }

            if codeLength == 3 {
                let ch = (UInt32(truncatingIfNeeded: self[index]) & 0x0F) << 12 +
                    (UInt32(truncatingIfNeeded: self[index + 1]) & 0x3F) << 6 +
                    UInt32(truncatingIfNeeded: self[index + 2]) & 0x3F
                if ch < 0x0800 || ch >> 11 == 0x1B {
                    return false
                }
            } else if codeLength == 4 {
                let ch = (UInt32(truncatingIfNeeded: self[index]) & 0x07) << 18 +
                    (UInt32(truncatingIfNeeded: self[index + 1]) & 0x3F) << 12 +
                    (UInt32(truncatingIfNeeded: self[index + 2]) & 0x3F) << 6 +
                    UInt32(truncatingIfNeeded: self[index + 3]) & 0x3F
                if ch < 0x10000 || ch > 0x10FFFF {
                    return false
                }
            }
            return true
        }
        // All bytes were in range 0...0x7F, which can be both in CP437 and UTF-8.
        // We solve this ambiguity in favor of CP437.
        return false
    }

}