struct Hexagon: Shape {
    func path(in rect: CGRect) -> Path {
        var path = Path()
        let center = CGPoint(x: rect.midX, y: rect.midY)
        let radius = min(rect.size.height, rect.size.width) / 2
        let corners = corners(center: center, radius: radius)
        path.move(to: corners[0])
        corners[1...5].forEach() { point in
            path.addLine(to: point)
        }
        path.closeSubpath()
        return path
    }
    
    func corners(center: CGPoint, radius: CGFloat) -> [CGPoint] {
        var points: [CGPoint] = []
        for i in (0...5) {
            let angle = CGFloat.pi / 3 * CGFloat(i)
            let point = CGPoint(
                x: center.x + radius * cos(angle),
                y: center.y + radius * sin(angle)
            )
            points.append(point)
        }
        return points
    }
}

struct CoordinatorView<C: CoordinatorViewable>: View {
    @ObservedObject var coordinator: C
    var body: some View {
        NavigationStack(path: $coordinator.navigationPath) {
            coordinator.getInitialPage().build(coordinator: coordinator)
                .navigationDestination(for: C.PageType.self) { page in
                    page.build(coordinator: coordinator)
                }
        }
        .sheet(item: $coordinator.sheet) { item in
            item.page.build(coordinator: coordinator)
        }
        .fullScreenCover(item: $coordinator.fullScreenCover) { item in
            item.page.build(coordinator: coordinator)
        }
        .onAppear {
            coordinator.start()
        }
    }
}

class DrawingSectionViewModel: ObservableObject {
    private(set) var coordinator: UIDrawingSectionViewCoordinator
    private var drawingService: any DrawingServiceProtocol
    
    init(drawing: UUID, drawingService: any DrawingServiceProtocol = RealtimeDBDrawingService()) {
        coordinator = .init()
        self.drawingService = drawingService
        Task { @MainActor in
            do {
                try await drawingService.subscribeToDrawing(id: drawing)
            } catch {
                print("Failed to subscribe to drawing \(drawing): \(error)")
            }
        }
    }
    
    private func onDrawingDidChange(_ drawing: PKDrawing) {
        Task { @MainActor in
            do {
                try await drawingService.updateDrawingData(newData: drawing)
            } catch {
                print("Error updating drawing: \(error)")
            }
        }
    }
}

public final class FirestoreDatabaseService<T: Codable>: DatabaseServiceProtocol {
    public typealias Model = T
    private let db = Firestore.firestore()
    private var listeners: [UUID: ListenerRegistration] = [:]
    
    public func addListener(for collection: String, using closure: @escaping ([T], (any Error)?) -> Void) async -> UUID {
        let id = UUID()
        let listener = db.collection(collection).addSnapshotListener({ snapshot, error in
            guard let snapshot else {
                closure([], error)
                return
            }
            let documents = snapshot.documents.compactMap{ doc -> T? in
                try? doc.data(as: T.self)
            }
            closure(documents, error)
        })
        listeners[id] = listener
        return id
    }
    
    public func addDocument(_ document: Model, to collection: String) async throws {
        do {
            try db.collection(collection).addDocument(from: document)
        } catch {
            NSLog("Error fetching documents from collection '(collection)': (error.localizedDescription)")
            throw error
        }
    }
}

final class RealtimeDBEventService: EventServiceProtocol {
    private let db: any DatabaseServiceProtocol<any Event>
    private let collectionPath: String
    func addEventListener(completion: @escaping (any Event) -> Void) async throws -> UUID {
        await db.addListener(for: collectionPath, using: { events, error in
            guard error == nil else { return }
            Task { @MainActor in
                for event in events {
                    completion(event)
                    try await self.db.deleteDocument(event.id.uuidString, from: self.collectionPath)
                }
            }
        })
    }
}

class GameManager {
    func handle(event: any Event) {
        switch event {
            case let e as PlayerJoinRoomEvent:
                handlePlayerJoinRoomEvent(e)
            case let e as PlayerLeaveRoomEvent:
                handlePlayerLeaveRoomEvent(e)
            case let e as PlayerJoinHiveEvent:
                handlePlayerJoinHiveEvent(e)
            case let e as PlayerLeaveHiveEvent:
                handlePlayerLeaveHiveEvent(e)
            case let e as RoomEndStepEvent:
                handleRoomEndStepEvent(e)
            default:
                print("Unhandled event: \(event)")
        }
    }
    func handleRoomEndStepEvent(_ event: RoomEndStepEvent) {
        Task { @MainActor in
            switch event.step {
                case .joining:
                    try await handleThemeReveal()
                case .themeReveal:
                    try await handleLeaderReveal()
                case .leaderReveal:
                    try await roomService.changeStep(to: .hivePairing)
                default:
                    try await roomService.changeStep(to: .end)
            }
        }
    }
}