import Foundation
import Combine

#if EVENT_MOYA_DOUBLE
public enum Method { case get }
public enum Task { case requestPlain }
public protocol TargetType {
    var baseURL: URL { get }
    var path: String { get }
    var method: Method { get }
    var task: Task { get }
    var headers: [String: String]? { get }
}
public struct Response {
    public let statusCode: Int
    public let data: Data
    public init(statusCode: Int, data: Data) {
        self.statusCode = statusCode
        self.data = data
    }
}
public enum MoyaError: Error { case simulatedTransportFailure }
public enum EventTransport {
    public static var request: ((any TargetType) -> AnyPublisher<Response, MoyaError>)!
}
public final class MoyaProvider<T: TargetType> {
    public init() {}
}
#elseif EVENT_COMBINE_MOYA_DOUBLE
import Moya
extension MoyaProvider {
    public func requestPublisher(_ target: T) -> AnyPublisher<Response, MoyaError> {
        EventTransport.request(target)
    }
}
#elseif EVENT_ROUTE_CHECK
@main
struct EventRouteCheck {
    static func main() throws {
        let root = CommandLine.arguments[1] + "/SodaLive/Sources/"
        let step = try String(contentsOfFile: root + "App/AppStep.swift", encoding: .utf8)
        guard step.contains("case eventDetail(eventId: Int)") else {
            fputs("FAIL: event detail route still retains payload instead of Int ID\n", stderr)
            exit(1)
        }
        let callers = ["Settings/Event/EventListView.swift", "Main/EventPopupDialogView.swift",
                       "Live/EventBanner/SectionEventBannerView.swift", "Content/Main/Banner/ContentMainBannerView.swift",
                       "Content/Main/V2/ContentMainBannerViewV2.swift", "V2/Main/MainView.swift"]
        var count = 0
        for file in callers {
            let source = try String(contentsOfFile: root + file, encoding: .utf8)
            let pattern = #"\.eventDetail\(\s*eventId:\s*[\w.!]+\.id\s*\)"#
            let matches = source.matches(of: try Regex(pattern)).count
            guard matches == (file == "V2/Main/MainView.swift" ? 2 : 1),
                  !source.contains(".eventDetail(event:") else {
                fatalError("ID-only caller missing: \(file)")
            }
            count += matches
        }
        let destination = try String(contentsOfFile: root + "ContentView.swift", encoding: .utf8)
        guard destination.contains("EventDetailView(eventId: eventId)") else { fatalError("ID destination missing") }
        print("PASS: supplementary ID-only route/destination and \(count) existing navigation call sites")
    }
}
#else
import Moya

let BASE_URL = "https://synthetic.invalid"
final class UserDefaults {
    static let standard = UserDefaults()
    private var values: [String: Any] = [:]
    func set(_ value: Any, forKey key: String) { values[key] = value }
    func object(forKey key: String) -> Any? { values[key] }
    func bool(forKey key: String) -> Bool { values[key] as? Bool ?? false }
    func string(forKey key: String) -> String? { values[key] as? String }
    func integer(forKey key: String) -> Int { values[key] as? Int ?? 0 }
    func data(forKey key: String) -> Data? { values[key] as? Data }
    func removeObject(forKey key: String) { values.removeValue(forKey: key) }
}
enum I18n { enum Common { static let commonError = "commonError" } }

@main
struct EventDetailCheck {
    static func expect(_ condition: @autoclosure () -> Bool, _ message: String) {
        if !condition() {
            fputs("FAIL: \(message)\n", stderr)
            exit(1)
        }
    }

    static func drainMainQueue() {
        var drained = false
        DispatchQueue.main.async { drained = true }
        let deadline = Date().addingTimeInterval(2)
        while !drained && Date() < deadline {
            RunLoop.main.run(until: Date().addingTimeInterval(0.001))
        }
        expect(drained, "Main queue did not drain")
    }

    static func json(id: Int = 42, fields: String = #", "detailImageUrl":null,"popupImageUrl":null,"link":null"#) -> String {
        #"{"success":true,"data":{"id":\#(id),"thumbnailImageUrl":"https://synthetic.invalid/thumb"\#(fields)},"message":null,"errorProperty":null}"#
    }

    static func response(_ json: String, status: Int = 200) -> Response {
        Response(statusCode: status, data: Data(json.utf8))
    }

    static func installTransport(_ subject: PassthroughSubject<Response, MoyaError>) {
        EventTransport.request = { target in
            expect(target.path == "/api/v2/events/42", "VM must use actual detail repository")
            return subject.eraseToAnyPublisher()
        }
    }

    static func checkAPI() {
        expect(Int.max == 9_223_372_036_854_775_807, "Supported Int must be signed 64-bit")
        let repository = EventRepository()
        for token in ["", "synthetic-token"] {
            UserDefaults.set(token, forKey: .token)
            var paths: [String] = []
            EventTransport.request = { target in
                paths.append(target.path)
                expect(target.baseURL.absoluteString == BASE_URL && target.method == .get, "Base URL or GET changed")
                guard case .requestPlain = target.task else { fatalError("No body/query permitted") }
                let legacy = target.path == "/event" || target.path == "/event/popup"
                expect(target.headers?["Authorization"] == (legacy || !token.isEmpty ? "Bearer \(token)" : nil),
                       "Detail optional auth or legacy headers changed")
                return Empty<Response, MoyaError>().eraseToAnyPublisher()
            }
            _ = repository.getEventDetail(id: 42)
            _ = repository.getEventDetail(id: 4_294_967_296)
            _ = repository.getEventDetail(id: Int.max)
            _ = repository.getEvents()
            _ = repository.getEventPopup()
            expect(paths == ["/api/v2/events/42", "/api/v2/events/4294967296", "/api/v2/events/9223372036854775807", "/event", "/event/popup"], "Repository paths/64-bit ID changed")
        }
        print("PASS: actual API/repository exact GET/requestPlain, anonymous/bearer, legacy routes/headers, >32-bit and Int.max")
    }

    static func checkSuccess() {
        for id in [42, 4_294_967_296, Int.max] {
            let subject = PassthroughSubject<Response, MoyaError>()
            var requests = 0
            EventTransport.request = { target in
                requests += 1
                expect(target.path == "/api/v2/events/\(id)", "ID truncated")
                return subject.eraseToAnyPublisher()
            }
            let model = EventDetailViewModel(eventId: id)
            var states: [EventDetailViewModel.State] = []
            let observation = model.$state.dropFirst().sink {
                expect(Thread.isMainThread, "State must publish on main")
                states.append($0)
            }
            model.load()
            model.load()
            expect(model.isLoading && model.state == .loading && requests == 1, "Loading must deduplicate")
            let sent = DispatchSemaphore(value: 0)
            DispatchQueue.global().async {
                subject.send(response(json(id: id)))
                subject.send(completion: .finished)
                sent.signal()
            }
            expect(sent.wait(timeout: .now() + 2) == .success, "Background response timed out")
            drainMainQueue()
            guard case .loaded(let item) = model.state else { fatalError("Object must load") }
            expect(item.id == id && item.thumbnailImageUrl == "https://synthetic.invalid/thumb", "Production DTO data lost")
            expect(item.detailImageUrl == nil && item.popupImageUrl == nil && item.link == nil, "Null optionals changed")
            expect(!model.isLoading && !model.isShowPopup && states.count == 2, "Loading or success publication wrong")
            model.cancel()
            model.load()
            expect(requests == 1, "Same loaded screen must not refetch on reappearance")
            withExtendedLifetime(observation) {}
        }
        for fields in ["", #", "detailImageUrl":"https://synthetic.invalid/detail""#,
                       #", "link":"https://synthetic.invalid/join""#,
                       #", "detailImageUrl":"https://synthetic.invalid/detail","link":"http://synthetic.invalid/join""#] {
            let subject = PassthroughSubject<Response, MoyaError>()
            installTransport(subject)
            let model = EventDetailViewModel(eventId: 42)
            model.load()
            subject.send(response(json(fields: fields)))
            subject.send(completion: .finished)
            drainMainQueue()
            guard case .loaded(let item) = model.state else { fatalError("Image-only/link-only/both/neither must load") }
            expect((model.participationURL != nil) == (item.link != nil), "Optional link must be independent of image")
        }
        print("PASS: actual DTO/VM single object, optional omitted/null, image-only/link-only/both/neither, 64-bit IDs, main delivery, no refetch")
    }

    static func checkUnavailableAndErrors() {
        for id in [0, -1, Int.min] {
            EventTransport.request = { _ in fatalError("Nonpositive ID must not request") }
            let model = EventDetailViewModel(eventId: id)
            model.load()
            model.load()
            expect(model.state == .unavailable && !model.isLoading, "Invalid ID unavailable/loading")
            expect(model.takeUnavailableDismissal() && !model.takeUnavailableDismissal(), "Invalid ID must dismiss once")
        }
        for data in ["null", "[]", "{}", #"{"id":"bad"}"#] {
            let subject = PassthroughSubject<Response, MoyaError>()
            installTransport(subject)
            let model = EventDetailViewModel(eventId: 42)
            var pops = 0
            let observation = model.$state.sink { state in
                if state == .unavailable && model.takeUnavailableDismissal() { pops += 1 }
            }
            model.load()
            let value = response(#"{"success":false,"data":\#(data),"message":"다른 언어의 메시지"}"#)
            subject.send(value)
            subject.send(value)
            subject.send(completion: .finished)
            drainMainQueue()
            model.load()
            expect(model.state == .unavailable && !model.isLoading && pops == 1, "False must ignore data shape/message and dismiss once")
            expect(!model.isShowPopup, "Unavailable must not become response-error toast")
            withExtendedLifetime(observation) {}
        }
        let failures: [(String, Int)] = [
            (#"{"success":true}"#, 200), (#"{"success":true,"data":null}"#, 200),
            (#"{"success":true,"data":[]}"#, 200), (#"{"success":true,"data":{}}"#, 200),
            (#"{"success":true,"data":{"id":42}}"#, 200),
            (#"{"success":true,"data":{"id":42,"thumbnailImageUrl":null}}"#, 200),
            (#"{"success":true,"data":{"id":42,"thumbnailImageUrl":7}}"#, 200),
            (json(id: 0), 200), (json(id: -1), 200), (json(id: 43), 200),
            (json(fields: #", "link":[]"#), 200), ("broken-json", 200),
            ("<html>unavailable</html>", 503), (json(), 503),
            (#"{"success":false,"data":null}"#, 503),
            (#"{"success":false,"data":null}"#, 401), (json(), 401), (json(), 201)
        ]
        for (payload, status) in failures {
            let subject = PassthroughSubject<Response, MoyaError>()
            installTransport(subject)
            let model = EventDetailViewModel(eventId: 42)
            model.load()
            subject.send(response(payload, status: status))
            subject.send(completion: .finished)
            drainMainQueue()
            expect(model.state == .error && !model.isLoading && model.isShowPopup, "HTTP \(status)/malformed success must be error")
            expect(model.errorMessage == I18n.Common.commonError && !model.takeUnavailableDismissal(), "Error must not pop/classify unavailable")
        }
        for transportFailure in [true, false] {
            let subject = PassthroughSubject<Response, MoyaError>()
            installTransport(subject)
            let model = EventDetailViewModel(eventId: 42)
            model.load()
            subject.send(completion: transportFailure ? .failure(.simulatedTransportFailure) : .finished)
            drainMainQueue()
            expect(model.state == .error && !model.isLoading && model.isShowPopup && !model.takeUnavailableDismissal(), "Transport/empty completion must terminate loading without pop")
        }
        print("PASS: nonpositive no request; false ignores malformed data/localized message; malformed success/HTML503/abnormal HTTP/401/transport stay error, loading ends, one dismissal")
    }

    static func checkLinksAndCancellation() {
        for link in ["https://synthetic.invalid/join", "http://synthetic.invalid/join", "HTTPS://synthetic.invalid/join",
                     "", " ", "/join", "//synthetic.invalid/join", "https:///", "https://", "not a URL",
                     "javascript:alert(1)", "data:text/plain,test", "file:///tmp/test", "sodalive://join", "mailto:a@example.invalid"] {
            let subject = PassthroughSubject<Response, MoyaError>()
            installTransport(subject)
            let model = EventDetailViewModel(eventId: 42)
            model.load()
            let encoded = String(data: try! JSONEncoder().encode(link), encoding: .utf8)!
            subject.send(response(json(fields: ",\"link\":\(encoded)")))
            drainMainQueue()
            guard case .loaded = model.state else { fatalError("Invalid link must not invalidate detail") }
            let allowed = ["https://synthetic.invalid/join", "http://synthetic.invalid/join", "HTTPS://synthetic.invalid/join"].contains(link)
            expect((model.participationURL != nil) == allowed, "Unsafe URL accepted or HTTP(S) rejected: \(link)")
        }
        let oldSubject = PassthroughSubject<Response, MoyaError>()
        let newSubject = PassthroughSubject<Response, MoyaError>()
        var requests = 0
        var cancels = 0
        EventTransport.request = { _ in
            requests += 1
            return (requests == 1 ? oldSubject : newSubject)
                .handleEvents(receiveCancel: { cancels += 1 }).eraseToAnyPublisher()
        }
        let model = EventDetailViewModel(eventId: 42)
        model.load()
        oldSubject.send(response(#"{"success":false,"data":null}"#))
        model.cancel()
        expect(!model.isLoading && model.state == .idle && cancels == 1, "Disappearance must cancel/reset pending request")
        oldSubject.send(response(json()))
        drainMainQueue()
        expect(model.state == .idle && !model.takeUnavailableDismissal(), "Queued/late response after disappearance must not change/pop")
        model.load()
        oldSubject.send(response(#"{"success":false,"data":null}"#))
        newSubject.send(response(json()))
        newSubject.send(response(#"{"success":false,"data":null}"#))
        drainMainQueue()
        guard case .loaded = model.state else { fatalError("Only new request's first response may win") }
        expect(requests == 2 && !model.takeUnavailableDismissal(), "Duplicate/old response must not pop another screen")
        let unavailableSubject = PassthroughSubject<Response, MoyaError>()
        installTransport(unavailableSubject)
        let unavailable = EventDetailViewModel(eventId: 42)
        unavailable.load()
        unavailableSubject.send(response(#"{"success":false,"data":null}"#))
        drainMainQueue()
        unavailable.cancel()
        expect(!unavailable.takeUnavailableDismissal(), "Disappeared unavailable view must not later dismiss another screen")
        print("PASS: actual participation URL HTTP(S)+host boundary; cancel/queued/late/stale/duplicate responses, reload after cancellation, disappearance suppresses dismissal")
    }

    static func main() {
        checkAPI()
        checkSuccess()
        checkUnavailableAndErrors()
        checkLinksAndCancellation()
        print("PASS: Event detail regression checks (actual production API/repository/VM/DTO, native Combine; no server calls)")
    }
}
#endif