//
//  ServerDataTests.swift
//  PadelClubTests
//
//  Created by Laurent Morvillier on 08/05/2024.
//

import XCTest
import LeStorage
@testable import PadelClub

final class ServerDataTests: XCTestCase {

    let username: String = "test"
    let password: String = "MyPass1234--"
    
    override func setUpWithError() throws {
        Store.main.synchronizationApiURL = "http://127.0.0.1:8000/roads/"
        Task {
            do {
                try await self.login()
            } catch {
                assertionFailure(error.localizedDescription)
            }
        }
    }

    override func tearDownWithError() throws {
        // Put teardown code here. This method is called after the invocation of each test method in the class.
    }
    
    func login() async throws {
//        print("LOGIN!")
        let _: User = try await Store.main.service().login(username: self.username, password: self.password)
    }
    
    func testClub() async throws {

        let club = Club(name: "Aix Universite Club")
        club.acronym = "AUC"
        club.city = "Aix en provence"
        club.zipCode = "13100"
        club.code = "abc"
        club.address = "2 avenue de la vie"
        club.latitude = 13
        club.longitude = 10
        club.phone = "061234567890"
        club.courtCount = 3
    
        let inserted_club: Club = try await Store.main.service().post(club)
        assert(inserted_club.name == club.name)
        assert(inserted_club.acronym == club.acronym)
        assert(inserted_club.zipCode == club.zipCode)
        assert(inserted_club.address == club.address)
        assert(inserted_club.latitude == club.latitude)
        assert(inserted_club.longitude == club.longitude)
        assert(inserted_club.phone == club.phone)
        assert(inserted_club.courtCount == club.courtCount)
        assert(inserted_club.broadcastCode != nil)
        
        inserted_club.phone = "123456"
        
        let updated_club: Club = try await Store.main.service().put(inserted_club)
        assert(updated_club.phone == inserted_club.phone)
        
    }

    func testLogin() async throws {
        let user: User = try await Store.main.service().login(username: self.username, password: self.password)
        assert(user.username == "test")
    }
    
    func testEvent() async throws {
        
        guard let userId = Store.main.userId else {
            assertionFailure("missing user UUID")
            return
        }
        
        let clubs: [Club] = try await Store.main.service().get()
        guard let clubId = clubs.first?.id else {
            assertionFailure("missing club in database")
            return
        }
        
        let event = Event(creator: userId, club: clubId, name: "Roland Garros", tenupId: "abc")
        let e = try await Store.main.service().post(event)
        
        assert(e.name == event.name)
        assert(e.tenupId == event.tenupId)
        
    }
    
    func testTournament() async throws {
        
        let event: [Event] = try await Store.main.service().get()
        guard let eventId = event.first?.id else {
            assertionFailure("missing event in database")
            return
        }
        
        let tournament = Tournament(event: eventId, name: "RG Homme", startDate: Date(), endDate: nil, creationDate: Date(), isPrivate: false, groupStageFormat: MatchFormat.megaTie, roundFormat: MatchFormat.nineGames, loserRoundFormat: MatchFormat.nineGamesDecisivePoint, groupStageSortMode: GroupStageOrderingMode.snake, groupStageCount: 2, rankSourceDate: Date(), dayDuration: 5, teamCount: 3, teamSorting: TeamSortingType.rank, federalCategory: TournamentCategory.mix, federalLevelCategory: TournamentLevel.p1000, federalAgeCategory: FederalTournamentAge.a45, closedRegistrationDate: Date(), groupStageAdditionalQualified: 4, courtCount: 9, prioritizeClubMembers: true, qualifiedPerGroupStage: 1, teamsPerGroupStage: 2, entryFee: 30.0, additionalEstimationDuration: 5, isDeleted: true, publishTeams: true, publishSummons: true, publishGroupStages: true, publishBrackets: true, shouldVerifyBracket: true, shouldVerifyGroupStage: true, hideTeamsWeight: true, publishTournament: true, hidePointsEarned: true)
        let t = try await Store.main.service().post(tournament)
        
        assert(t.event == tournament.event)
        assert(t.name == tournament.name)
        assert(t.startDate.formatted() == tournament.startDate.formatted())
        assert(t.endDate?.formatted() == tournament.endDate?.formatted())
        assert(t.creationDate.formatted() == tournament.creationDate.formatted())
        assert(t.isPrivate == tournament.isPrivate)
        assert(t.groupStageFormat == tournament.groupStageFormat)
        assert(t.roundFormat == tournament.roundFormat)
        assert(t.loserRoundFormat == tournament.loserRoundFormat)
        assert(t.groupStageSortMode == tournament.groupStageSortMode)
        assert(t.groupStageCount == tournament.groupStageCount)
        assert(t.rankSourceDate?.formatted() == tournament.rankSourceDate?.formatted())
        assert(t.dayDuration == tournament.dayDuration)
        assert(t.teamCount == tournament.teamCount)
        assert(t.teamSorting == tournament.teamSorting)
        assert(t.federalCategory == tournament.federalCategory)
        assert(t.federalLevelCategory == tournament.federalLevelCategory)
        assert(t.federalAgeCategory == tournament.federalAgeCategory)
        assert(t.closedRegistrationDate?.formatted() == tournament.closedRegistrationDate?.formatted())
        assert(t.groupStageAdditionalQualified == tournament.groupStageAdditionalQualified)
        assert(t.courtCount == tournament.courtCount)
        assert(t.prioritizeClubMembers == tournament.prioritizeClubMembers)
        assert(t.qualifiedPerGroupStage == tournament.qualifiedPerGroupStage)
        assert(t.teamsPerGroupStage == tournament.teamsPerGroupStage)
        assert(t.entryFee == tournament.entryFee)
        assert(t.additionalEstimationDuration == tournament.additionalEstimationDuration)
        assert(t.isDeleted == tournament.isDeleted)
        assert(t.publishTeams == tournament.publishTeams)
        assert(t.publishSummons == tournament.publishSummons)
        assert(t.publishGroupStages == tournament.publishGroupStages)
        assert(t.publishBrackets == tournament.publishBrackets)
        assert(t.shouldVerifyBracket == tournament.shouldVerifyBracket)
        assert(t.shouldVerifyGroupStage == tournament.shouldVerifyGroupStage)
        assert(t.hideTeamsWeight == tournament.hideTeamsWeight)
        assert(t.publishTournament == tournament.publishTournament)
        assert(t.hidePointsEarned == tournament.hidePointsEarned)
    }
    
    func testGroupStage() async throws {
        
        let tournament: [Tournament] = try await Store.main.service().get()
        guard let tournamentId = tournament.first?.id else {
            assertionFailure("missing tournament in database")
            return
        }
        
        let groupStage = GroupStage(tournament: tournamentId, index: 2, size: 3, matchFormat: MatchFormat.nineGames, startDate: Date(), name: "Yeah!")
        let gs: GroupStage = try await Store.main.service().post(groupStage)
        
        assert(gs.tournament == groupStage.tournament)
        assert(gs.name == groupStage.name)
        assert(gs.index == groupStage.index)
        assert(gs.size == groupStage.size)
        assert(gs.matchFormat == groupStage.matchFormat)
        assert(gs.startDate != nil)
        
    }
    
    func testRound() async throws {
        
        let tournament: [Tournament] = try await Store.main.service().get()
        guard let tournamentId = tournament.first?.id else {
            assertionFailure("missing tournament in database")
            return
        }
        let rounds: [Round] = try await Store.main.service().get()
        let parentRoundId = rounds.first?.id
        
        let round = Round(tournament: tournamentId, index: 1, parent: parentRoundId, matchFormat: MatchFormat.nineGames, startDate: Date())
        let r: Round = try await Store.main.service().post(round)
        
        assert(r.tournament == round.tournament)
        assert(r.index == round.index)
        assert(r.parent == round.parent)
        assert(r.matchFormat == round.matchFormat)
        assert(r.startDate != nil)
        
    }
    
    func testTeamRegistration() async throws {
        
        let tournament: [Tournament] = try await Store.main.service().get()
        guard let tournamentId = tournament.first?.id else {
            assertionFailure("missing tournament in database")
            return
        }
        let groupStages: [GroupStage] = try await Store.main.service().get()
        guard let groupStageId = groupStages.first?.id else {
            assertionFailure("missing groupStage in database")
            return
        }

        let teamRegistration = TeamRegistration(tournament: tournamentId, groupStage: groupStageId, registrationDate: Date(), callDate: Date(), bracketPosition: 1, groupStagePosition: 2, comment: "comment", source: "source", sourceValue: "source V", logo: "logo", name: "Stax", walkOut: true, wildCardBracket: true, wildCardGroupStage: true, weight: 1, lockedWeight: 11, confirmationDate: Date(), qualified: true)
                
        let tr: TeamRegistration = try await Store.main.service().post(teamRegistration)
        
        assert(tr.tournament == teamRegistration.tournament)
        assert(tr.groupStage == teamRegistration.groupStage)
        assert(tr.registrationDate != nil)
        assert(tr.callDate != nil)
        assert(tr.bracketPosition == teamRegistration.bracketPosition)
        assert(tr.groupStagePosition == teamRegistration.groupStagePosition)
        assert(tr.comment == teamRegistration.comment)
        assert(tr.source == teamRegistration.source)
        assert(tr.sourceValue == teamRegistration.sourceValue)
        assert(tr.logo == teamRegistration.logo)
        assert(tr.name == teamRegistration.name)
        assert(tr.walkOut == teamRegistration.walkOut)
        assert(tr.wildCardBracket == teamRegistration.wildCardBracket)
        assert(tr.wildCardGroupStage == teamRegistration.wildCardGroupStage)
        assert(tr.weight == teamRegistration.weight)
        assert(tr.lockedWeight == teamRegistration.lockedWeight)
        assert(tr.confirmationDate?.formatted() == teamRegistration.confirmationDate?.formatted())
        assert(tr.qualified == teamRegistration.qualified)

    }
    
    func testPlayerRegistration() async throws {
        
        let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
        guard let teamRegistrationId = teamRegistrations.first?.id else {
            assertionFailure("missing teamRegistrations in database")
            return
        }

        let playerRegistration = PlayerRegistration(teamRegistration: teamRegistrationId, firstName: "juan", lastName: "lebron", licenceId: "123", rank: 11, paymentType: PlayerRegistration.PlayerPaymentType.cash, sex: PlayerRegistration.PlayerSexType.male, tournamentPlayed: 2, points: 33, clubName: "le club", ligueName: "la league", assimilation: "ass", phoneNumber: "123123", email: "email@email.com", birthdate: nil, computedRank: 222, source: PlayerRegistration.PlayerDataSource.frenchFederation, hasArrived: true)
        let pr: PlayerRegistration = try await Store.main.service().post(playerRegistration)
        
        assert(pr.teamRegistration == playerRegistration.teamRegistration)
        assert(pr.firstName == playerRegistration.firstName)
        assert(pr.lastName == playerRegistration.lastName)
        assert(pr.licenceId == playerRegistration.licenceId)
        assert(pr.rank == playerRegistration.rank)
        assert(pr.paymentType == playerRegistration.paymentType)
        assert(pr.sex == playerRegistration.sex)
        assert(pr.tournamentPlayed == playerRegistration.tournamentPlayed)
        assert(pr.points == playerRegistration.points)
        assert(pr.clubName == playerRegistration.clubName)
        assert(pr.ligueName == playerRegistration.ligueName)
        assert(pr.assimilation == playerRegistration.assimilation)
        assert(pr.phoneNumber == playerRegistration.phoneNumber)
        assert(pr.birthdate == playerRegistration.birthdate)
        assert(pr.computedRank == playerRegistration.computedRank)
        assert(pr.source == playerRegistration.source)
        assert(pr.hasArrived == playerRegistration.hasArrived)
        
    }
    
    func testMatch() async throws {
        
        let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
        guard let teamRegistrationId = teamRegistrations.first?.id else {
            assertionFailure("missing teamRegistrations in database")
            return
        }
        let rounds: [Round] = try await Store.main.service().get()
        let parentRoundId = rounds.first?.id
        
        let match: Match = Match(round: parentRoundId, groupStage: nil, startDate: Date(), endDate: Date(), index: 2, matchFormat: MatchFormat.twoSets, servingTeamId: teamRegistrationId, winningTeamId: teamRegistrationId, losingTeamId: teamRegistrationId, disabled: true, courtIndex: 1, confirmed: true)
        let m: Match = try await Store.main.service().post(match)
        
        assert(m.round == match.round)
        assert(m.groupStage == match.groupStage)
        assert(m.startDate != nil)
        assert(m.endDate != nil)
        assert(m.index == match.index)
        assert(m.matchFormat == match.matchFormat)
        assert(m.servingTeamId == match.servingTeamId)
        assert(m.winningTeamId == match.winningTeamId)
        assert(m.losingTeamId == match.losingTeamId)
        assert(m.disabled == match.disabled)
        assert(m.courtIndex == match.courtIndex)
        assert(m.confirmed == match.confirmed)

    }
    
    func testTeamScore() async throws {
        
        let matches: [Match] = try await Store.main.service().get()
        guard let matchId = matches.first?.id else {
            assertionFailure("missing match in database")
            return
        }
        let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
        guard let teamRegistrationId = teamRegistrations.first?.id else {
            assertionFailure("missing teamRegistrations in database")
            return
        }
        let teamScore = TeamScore(match: matchId, teamRegistration: teamRegistrationId, score: "6/6", walkOut: 1, luckyLoser: 1)
        let ts: TeamScore = try await Store.main.service().post(teamScore)
        
        assert(ts.match == teamScore.match)
        assert(ts.teamRegistration == teamScore.teamRegistration)
        assert(ts.score == teamScore.score)
        assert(ts.walkOut == teamScore.walkOut)
        assert(ts.luckyLoser == teamScore.luckyLoser)
        
    }
    
    func testCourt() async throws {
                
        let clubs: [Club] = try await Store.main.service().get()
        guard let clubId = clubs.first?.id else {
            assertionFailure("missing club in database")
            return
        }
        
        let court = Court(index: 1, club: clubId, name: "Philippe Chatrier", exitAllowed: true, indoor: true)
        let c: Court = try await Store.main.service().post(court)
        
        assert(c.club == court.club)
        assert(c.name == court.name)
        assert(c.index == court.index)
        assert(c.exitAllowed == court.exitAllowed)
        assert(c.indoor == court.indoor)
        
    }
    
    func testDateInterval() async throws {
        
        let event: [Event] = try await Store.main.service().get()
        guard let eventId = event.first?.id else {
            assertionFailure("missing event in database")
            return
        }
        
        let dateInterval = DateInterval(event: eventId, courtIndex: 1, startDate: Date(), endDate: Date())
        let di: PadelClub.DateInterval = try await Store.main.service().post(dateInterval)
        
        assert(di.event == dateInterval.event)
        assert(di.courtIndex == dateInterval.courtIndex)
        assert(di.startDate.formatted() == dateInterval.startDate.formatted())
        assert(di.endDate.formatted() == dateInterval.endDate.formatted())
        
    }
    
    func testPurchase() async throws {
        
        guard let userId = Store.main.userId else {
            assertionFailure("missing user UUID")
            return
        }
        
        let purchase: Purchase = Purchase(user: userId, identifier: 1234, purchaseDate: Date(), productId: "productId", quantity: 3, revocationDate: Date())
        let p: Purchase = try await Store.main.service().post(purchase)
        
        assert(p.id == purchase.id)
        assert(p.identifier == purchase.identifier)
        assert(p.productId == purchase.productId)
        assert(p.purchaseDate.formatted() == purchase.purchaseDate.formatted())
        assert(p.quantity == purchase.quantity)
        assert(p.user == purchase.user)
        assert(p.revocationDate?.formatted() == purchase.revocationDate?.formatted())
        
    }
    
}
