import Foundation
import WebSocketKit
import Vapor
import Fluent

let maximumPlayersPerTable = 4

typealias TableId = String
typealias TableName = String

final class TableManagement {
    
    /// All tables indexed by their id
    private var tables = [UUID : ManageableTable]()
    
    /**
     Load the tables from a file in the storage folder
     - Throws: Errors when the file could not be read
     */
    init(db: Database) throws {
        Table.query(on: db).with(\.$players).all().whenSuccess { loadedTables in
            for table in loadedTables {
                guard !table.players.isEmpty else {
                    _ = table.delete(on: db)
                    continue
                }
                let id = table.id!
                self.tables[id] = WaitingTable(id: id, name: table.name, isPublic: table.isPublic, players: table.players)
            }
            print("\(self.tables.count) tables loaded")
        }
    }

    /**
     Create a new table with optional players.
     - Parameter name: The name of the table
     - Parameter players: The player creating the table
     - Parameter isPublic: Indicates that this is a game joinable by everyone
     - Returns: The table id
     */
    func createTable(named name: TableName, player: User, isPublic: Bool, in database: Database) -> EventLoopFuture<TableInfo> {
        let table = Table(name: name, isPublic: isPublic)
        return table.create(on: database).flatMap {
            player.$table.id = table.id
            return player.update(on: database)
        }.flatMap {
            Table.query(on: database).with(\.$players).filter(\.$id == table.id!).first()
        }.unwrap(or: Abort(.notFound))
            .map { storedTable in
            let table = WaitingTable(newTable: storedTable)
            self.tables[table.id] = table
            return table.tableInfo(forPlayer: player.name)
        }
    }
    
    /// A list of all public tables
    var publicTableList: [PublicTableInfo] {
        tables.values.filter { $0.isPublic }.map { $0.publicInfo }
    }

    /**
     Get the table info for a player
     - Parameter player: The name of the player
     - Returns: The table info, if the player has joined a table
     */
    func tableInfo(player: PlayerName) -> TableInfo? {
        currentTable(for: player)?.tableInfo(forPlayer: player)
    }

    private func currentTable(for player: PlayerName) -> ManageableTable? {
        tables.values.first(where: { $0.playerNames.contains(player) })
    }
    
    /**
     Join a table.
     - Parameter tableId: The table to join
     - Parameter player: The name of the player who wants to join.
     - Returns: The result of the join operation
     */
    func join(tableId: UUID, player: User, in database: Database) -> EventLoopFuture<TableInfo> {
        return database.eventLoop.future().flatMapThrowing { _ -> ManageableTable in
            if let existing = self.currentTable(for: player.name) {
                guard existing.id == tableId else {
                    throw Abort(.forbidden) // 403
                }
                return existing
            }
            guard let table = self.tables[tableId] else {
                throw Abort(.gone) // 410
            }
            guard let joinableTable = table as? WaitingTable,
                  joinableTable.add(player: player.name, points: player.points) else {
                      throw Abort(.expectationFailed) // 417
                  }
            return joinableTable
        }.flatMap { table -> EventLoopFuture<ManageableTable> in
            player.$table.id = table.id
            return player.update(on: database).map { table }
        }.map { table in
            table.sendUpdateToAllPlayers()
            return table.tableInfo(forPlayer: player.name)
        }
    }
    
    /**
     A player leaves the table it previously joined
     - Parameter player: The player leaving the table
     */
    func leaveTable(player: User, in database: Database) -> EventLoopFuture<Void> {
        guard let oldTable = currentTable(for: player.name) else {
            return database.eventLoop.makeSucceededVoidFuture()
        }
        player.$table.id = nil
        guard let table = WaitingTable(oldTable: oldTable, removing: player.name) else {
            tables[oldTable.id] = nil
            return player.update(on: database).flatMap {
                Table.query(on: database).filter(\.$id == oldTable.id).delete()
            }
        }
        /// `player.canStartGame` is automatically set to false, because table is not full
        tables[table.id] = table
        table.sendUpdateToAllPlayers()
        // TODO: Update points for all players
        return player.update(on: database)
    }
    
    func connect(player: PlayerName, using socket: WebSocket) -> Bool {
        guard let table = currentTable(for: player) else {
            return false
        }
        return table.connect(player: player, using: socket)
    }
    
    func disconnect(player: PlayerName) {
        guard let table = currentTable(for: player) else {
            return
        }
        table.disconnect(player: player)
    }
    
    func performAction(player: PlayerName, action: PlayerAction) -> PlayerActionResult {
        guard let table = currentTable(for: player) else {
            print("Player \(player) wants to \(action.id), but no table joined")
            return .noTableJoined
        }
        let (result, newTable) = table.perform(action: action, forPlayer: player)
        guard result == .success else {
            return result
        }
        guard let newTable = newTable else {
            table.sendUpdateToAllPlayers()
            return .success
        }
        tables[newTable.id] = newTable
        newTable.sendUpdateToAllPlayers()
        if newTable is FinishedTable || newTable is DealingTable {
            // TODO: Save new table
        }
        return .success
    }

    func select(game: GameType, player: PlayerName) -> PlayerActionResult {
        guard let aTable = currentTable(for: player) else {
            print("Player \(player) wants to play \(game.rawValue), but no table joined")
            return .noTableJoined
        }
        guard let table = aTable as? BiddingTable else {
            return .tableStateInvalid
        }
        let (result, newTable) = table.select(game: game, player: player)
        guard result == .success else {
            return result
        }
        guard let newTable = newTable else {
            print("Game selected by \(player), but no playing table \(table.name) created")
            table.sendUpdateToAllPlayers()
            return result
        }
        tables[newTable.id] = newTable
        newTable.sendUpdateToAllPlayers()
        // TODO: Save new table
        return .success
    }

    func play(card: Card, player: PlayerName) -> PlayerActionResult {
        guard let table = currentTable(for: player) else {
            return .noTableJoined
        }
        let (result, newTable) = table.play(card: card, player: player)
        guard result == .success else {
            return result
        }
        guard let newTable = newTable else {
            table.sendUpdateToAllPlayers()
            return .success
        }
        tables[newTable.id] = newTable
        newTable.sendUpdateToAllPlayers()
        // TODO: Save new table
        return .success
    }
    
    func disconnectAllSockets() {
        tables.values.forEach { $0.disconnectAllPlayers() }
    }
}