import Foundation

public extension InteractiveTextFormatter {
    struct ParsedTimestamp {
        public let text: String
        public let seconds: Double
        public let range: NSRange

        public init(text: String, seconds: Double, range: NSRange) {
            self.text = text
            self.seconds = seconds
            self.range = range
        }
    }

    private static let timestampRegex: NSRegularExpression? = {
        let timestampPattern = #"(?:^|\s)(\d{1,2}:\d{2}(?::\d{2})?)(?=\s|$|[^\d:])"#
        return try? NSRegularExpression(pattern: timestampPattern, options: [])
    }()

    static func parseTimestamps(from text: String) -> [ParsedTimestamp] {
        guard let timestampRegex = timestampRegex else { return [] }

        let textRange = NSRange(location: 0, length: text.count)
        let regexMatches = timestampRegex.matches(in: text, options: [], range: textRange)

        return regexMatches.compactMap { match -> ParsedTimestamp? in
            guard match.numberOfRanges > 1 else { return nil }

            let timestampRange = match.range(at: 1)
            guard let stringRange = Range(timestampRange, in: text) else { return nil }

            let timestampString = String(text[stringRange])
            guard let validSeconds = parseAndValidateTimeString(timestampString) else { return nil }

            return ParsedTimestamp(
                text: timestampString,
                seconds: validSeconds,
                range: timestampRange
            )
        }
    }

    /// Converts time string to seconds with validation (e.g., "1:20" -> 80.0, "2:15:30" -> 8130.0)
    static func parseAndValidateTimeString(_ timeString: String) -> Double? {
        let timeComponents = timeString.split(separator: ":").map(String.init)
        let totalSeconds: Double

        switch timeComponents.count {
        case 2:
            // mm:ss format
            guard let minutes = Double(timeComponents[0]),
                  let seconds = Double(timeComponents[1]),
                  seconds < 60 else { return nil }
            totalSeconds = minutes * 60 + seconds

        case 3:
            // hh:mm:ss format
            guard let hours = Double(timeComponents[0]),
                  let minutes = Double(timeComponents[1]),
                  let seconds = Double(timeComponents[2]),
                  minutes < 60, seconds < 60 else { return nil }
            totalSeconds = hours * 3600 + minutes * 60 + seconds

        default:
            return nil
        }

        // Validate bounds
        // TODO: Add upper limit to # seconds at some point
        guard totalSeconds >= 0 else { return nil }

        return totalSeconds
    }
}