OSGKeyboard/OSGKeyboardShared/Services/AIEventExtraction.swift

// AIEventExtraction.swift
// OSGKeyboard · Shared
//
// Parses the LLM's extract-events reply into Shortcut lines. Fail closed:
// empty / NONE / lines without a parseable start never become a run.
// Canonical line: start|end|title|location
// All-day uses end token ALLDAY so the companion Shortcut can branch.

import Foundation

public enum AIEventExtraction: Sendable {
    public static let maximumItems = 20
    public static let defaultDuration: TimeInterval = 3600
    /// End-field sentinel for all-day events (Shortcut If equals this).
    public static let allDaySentinel = "ALLDAY"

    private static let emptyTokens: Set<String> = [
        "none", "no", "n/a", "na", "nil", "null",
        "无", "没有", "没有日程", "没有事件", "无日程",
        "没有日期", "没有时间", "没有日期或时间", "没有日期和时间",
        "no events", "no event", "no calendar events",
        "no date", "no time", "no date or time", "no date and time"
    ]

    /// Lines to send to the companion Shortcut. Empty → do not run it.
    public static func lines(
        from raw: String,
        sourceClipboard: String? = nil,
        now: Date = Date(),
        calendar: Calendar = .current
    ) -> [String] {
        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else { return [] }
        if isEmptyToken(trimmed) { return [] }

        var seen = Set<String>()
        var items: [String] = []
        for line in trimmed.components(separatedBy: .newlines) {
            guard let encoded = encodeLine(
                line,
                now: now,
                calendar: calendar
            ) else { continue }
            let key = encoded.lowercased()
            guard seen.insert(key).inserted else { continue }
            items.append(encoded)
            if items.count == maximumItems { break }
        }

        if items.count == 1, isWholeClipboardEcho(items[0], source: sourceClipboard) {
            return []
        }
        return items
    }

    // MARK: - Decode

    /// One calendar event decoded from a canonical `lines(...)` entry, ready to
    /// hand to EventKit. `end` is nil only for an all-day event (`isAllDay`).
    public struct ParsedEvent: Sendable, Equatable {
        public let title: String
        public let location: String?
        public let start: Date
        public let end: Date?
        public let isAllDay: Bool

        public init(title: String, location: String?, start: Date, end: Date?, isAllDay: Bool) {
            self.title = title
            self.location = location
            self.start = start
            self.end = end
            self.isAllDay = isAllDay
        }
    }

    /// Inverse of the encoding produced by `lines(...)`. Strict: only accepts the
    /// canonical `start|end|title|location` shape this type emits. Returns nil for
    /// anything it cannot fully parse so the host never writes a malformed event.
    public static func decode(_ line: String, calendar: Calendar = .current) -> ParsedEvent? {
        let fields = line
            .split(separator: "|", omittingEmptySubsequences: false)
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
        guard fields.count >= 3 else { return nil }
        let startRaw = fields[0]
        let endRaw = fields[1]
        let title = fields[2]
        guard !title.isEmpty else { return nil }
        let location: String? = {
            guard fields.count >= 4 else { return nil }
            let joined = fields[3...].joined(separator: "|")
                .trimmingCharacters(in: .whitespacesAndNewlines)
            return joined.isEmpty ? nil : joined
        }()

        // All-day: start is a bare day, end is the ALLDAY sentinel.
        if endRaw.caseInsensitiveCompare(allDaySentinel) == .orderedSame {
            guard let day = date(from: startRaw, format: "yyyy-MM-dd", calendar: calendar) else {
                return nil
            }
            return ParsedEvent(
                title: title,
                location: location,
                start: calendar.startOfDay(for: day),
                end: nil,
                isAllDay: true
            )
        }

        // Timed: both ends are minute-precision timestamps.
        guard let start = date(from: startRaw, format: "yyyy-MM-dd HH:mm", calendar: calendar) else {
            return nil
        }
        let end = date(from: endRaw, format: "yyyy-MM-dd HH:mm", calendar: calendar)
            ?? start.addingTimeInterval(defaultDuration)
        return ParsedEvent(
            title: title,
            location: location,
            start: start,
            end: max(end, start.addingTimeInterval(60)),
            isAllDay: false
        )
    }

    // MARK: - Line

    private static func encodeLine(
        _ line: String,
        now: Date,
        calendar: Calendar
    ) -> String? {
        let fields = splitFields(line)
        guard fields.count >= 2 else { return nil }

        let startRaw = fields[0]
        let endRaw: String
        let titleRaw: String
        let locationRaw: String
        switch fields.count {
        case 2:
            endRaw = ""
            titleRaw = fields[1]
            locationRaw = ""
        case 3:
            // 3 fields: start|end|title if segment 2 is a time/empty;
            // otherwise start|title|location.
            if fields[1].isEmpty || parseInstant(fields[1], on: now, calendar: calendar) != nil {
                endRaw = fields[1]
                titleRaw = fields[2]
                locationRaw = ""
            } else {
                endRaw = ""
                titleRaw = fields[1]
                locationRaw = fields[2]
            }
        default:
            endRaw = fields[1]
            titleRaw = fields[2]
            locationRaw = fields[3]
        }

        let title = stripBullet(titleRaw)
        guard !title.isEmpty, !isEmptyToken(title) else { return nil }
        let location = locationRaw.trimmingCharacters(in: .whitespacesAndNewlines)

        guard let start = parseInstant(startRaw, on: now, calendar: calendar) else {
            return nil
        }

        switch start {
        case .allDay(let day):
            return encode(
                start: formatDay(day, calendar: calendar),
                end: allDaySentinel,
                title: title,
                location: location
            )
        case .timed(let startDate, _):
            let endDate = resolveEnd(
                endRaw,
                start: startDate,
                calendar: calendar
            )
            return encode(
                start: formatMinute(startDate, calendar: calendar),
                end: formatMinute(endDate, calendar: calendar),
                title: title,
                location: location
            )
        }
    }

    /// Split on `|` and keep at most 4 fields; extra segments join into location.
    private static func splitFields(_ line: String) -> [String] {
        let parts = line
            .split(separator: "|", omittingEmptySubsequences: false)
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
        guard parts.count > 4 else { return parts }
        let location = parts[3...].joined(separator: "|")
        return [parts[0], parts[1], parts[2], location]
    }

    private static func encode(start: String, end: String, title: String, location: String) -> String {
        "\(start)|\(end)|\(title)|\(location)"
    }

    // MARK: - Time

    private enum Instant {
        case allDay(Date)
        case timed(Date, timeOnly: Bool)
    }

    private static func parseInstant(
        _ raw: String,
        on day: Date,
        calendar: Calendar
    ) -> Instant? {
        let text = raw.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !text.isEmpty else { return nil }
        if text.caseInsensitiveCompare(allDaySentinel) == .orderedSame {
            return .allDay(calendar.startOfDay(for: day))
        }

        for format in ["yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM-dd'T'HH:mm:ss", "yyyy-MM-dd'T'HH:mm"] {
            if let date = date(from: text, format: format, calendar: calendar) {
                return .timed(date, timeOnly: false)
            }
        }
        if let date = date(from: text, format: "yyyy-MM-dd", calendar: calendar) {
            return .allDay(calendar.startOfDay(for: date))
        }
        for format in ["HH:mm:ss", "HH:mm", "H:mm"] {
            if let parsed = date(from: text, format: format, calendar: calendar) {
                let parts = calendar.dateComponents([.hour, .minute, .second], from: parsed)
                guard let combined = calendar.date(
                    bySettingHour: parts.hour ?? 0,
                    minute: parts.minute ?? 0,
                    second: 0,
                    of: day
                ) else { return nil }
                return .timed(combined, timeOnly: true)
            }
        }
        return nil
    }

    private static func resolveEnd(
        _ raw: String,
        start: Date,
        calendar: Calendar
    ) -> Date {
        let fallback = start.addingTimeInterval(defaultDuration)
        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty,
              trimmed.caseInsensitiveCompare(allDaySentinel) != .orderedSame else {
            return fallback
        }
        guard let parsed = parseInstant(trimmed, on: start, calendar: calendar) else {
            return fallback
        }
        let end: Date
        switch parsed {
        case .allDay(let day):
            // Date-only end with a timed start: use that calendar day at 23:59.
            end = calendar.date(bySettingHour: 23, minute: 59, second: 0, of: day) ?? fallback
        case .timed(let date, let timeOnly):
            if timeOnly, date <= start {
                end = calendar.date(byAdding: .day, value: 1, to: date) ?? fallback
            } else {
                end = date
            }
        }
        return end <= start ? fallback : end
    }

    private static func date(from text: String, format: String, calendar: Calendar) -> Date? {
        let formatter = DateFormatter()
        formatter.calendar = calendar
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = calendar.timeZone
        formatter.isLenient = false
        formatter.dateFormat = format
        return formatter.date(from: text)
    }

    private static func formatDay(_ date: Date, calendar: Calendar) -> String {
        format(date, "yyyy-MM-dd", calendar: calendar)
    }

    private static func formatMinute(_ date: Date, calendar: Calendar) -> String {
        format(date, "yyyy-MM-dd HH:mm", calendar: calendar)
    }

    private static func format(_ date: Date, _ format: String, calendar: Calendar) -> String {
        let formatter = DateFormatter()
        formatter.calendar = calendar
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = calendar.timeZone
        formatter.dateFormat = format
        return formatter.string(from: date)
    }

    // MARK: - Tokens

    private static func isEmptyToken(_ text: String) -> Bool {
        let folded = text
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .trimmingCharacters(in: CharacterSet(charactersIn: "。.!！"))
            .lowercased()
        return emptyTokens.contains(folded)
    }

    private static func stripBullet(_ line: String) -> String {
        var text = line.trimmingCharacters(in: .whitespacesAndNewlines)
        let prefixes = ["- ", "* ", "• ", "、"]
        for prefix in prefixes where text.hasPrefix(prefix) {
            text = String(text.dropFirst(prefix.count))
                .trimmingCharacters(in: .whitespacesAndNewlines)
        }
        if let dotted = text.range(of: #"^\d+[\.\)、]\s*"#, options: .regularExpression) {
            text = String(text[dotted.upperBound...])
                .trimmingCharacters(in: .whitespacesAndNewlines)
        }
        return text
    }

    /// One long title that is essentially the clipboard body is not an event.
    private static func isWholeClipboardEcho(_ item: String, source: String?) -> Bool {
        guard let source, source.count > 80 else { return false }
        let fields = item.split(separator: "|", omittingEmptySubsequences: false)
        guard fields.count >= 3 else { return false }
        let title = String(fields[2])
        guard title.count > 80 else { return false }
        let a = collapse(title)
        let b = collapse(source)
        guard !a.isEmpty, !b.isEmpty else { return false }
        if a == b { return true }
        return a.contains(b) || b.contains(a)
    }

    private static func collapse(_ text: String) -> String {
        text.components(separatedBy: .whitespacesAndNewlines)
            .filter { !$0.isEmpty }
            .joined(separator: " ")
            .lowercased()
    }
}