class MainViewController: UIViewController, EGCDelegate {
    /**
        This method is called after the view controller has loaded
    */
    override func viewDidLoad() {
        super.viewDidLoad()

        // Init EGC and set delegate UIViewController
        EGC.sharedInstance(self)

        // Will not show automatic Game Center login page
        // EGC.showLoginPage = false

        // If you want see message debug
        // EGC.debugMode = true
    }
    /**
        Notifies the view controller that its view was added to a view hierarchy.
    */
    override func viewDidAppear(animated: Bool) {
        super.viewDidAppear(animated)

        // Set new view controller delegate, that's when you change UIViewController
        // If you have several UIViewController just add this in your UIViewControllers for set new Delegate
        EGC.delegate = self
    }

    /// ############################################################ ///
    ///        Mark: - Delegate function of EasyGameCenter           ///
    /// ############################################################ ///
    /**
        Listener Player is authentified 
        Optional function
    */
    func EGCAuthentified(authentified:Bool) {
        print("Player Authentified = \(authentified)")
    }
    /**
        Listener when Achievements is in cache
        Optional function
    */
    func EGCInCache() {
        // Call when GkAchievement & GKAchievementDescription in cache
    }

    /// ############################################################ ///
    ///  Mark: - Delegate function of EasyGameCenter for MultiPlaye  ///
    /// ############################################################ ///
    /**
        Listener When Match Started
        Optional function
    */
    func EGCMatchStarted() {
        print("MatchStarted")
    }
    /**
        Listener When Match Recept Data
        When player send data to all player
        Optional function
    */
    func EGCMatchRecept(match: GKMatch, didReceiveData data: NSData, fromPlayer playerID: String) {
        // See Packet Example in project
        let strucData =  Packet.unarchive(data)
        print("Recept From player = \(playerID)")
        print("Recept Packet.name = \(strucData.name)")
        print("Recept Packet.index = \(strucData.index)")
    }
    /**
        Listener When Match End
        Optional function
    */
    func EGCMatchEnded() {
        print("MatchEnded")
    }
    /**
        Listener When Match Cancel
        Optional function
    */
    func EGCMatchCancel() {
        print("Match cancel")
    }

    EGC.showGameCenterAchievements()

    EGC.showGameCenterAchievements { 
        (isShow) -> Void in
        if isShow {
                print("Game Center Achievements is shown")
        }
    }

    EGC.showGameCenterLeaderboard(leaderboardIdentifier: "IdentifierLeaderboard")

    EGC.showGameCenterLeaderboard(leaderboardIdentifier: "IdentifierLeaderboard") { 
        (isShow) -> Void in
        if isShow {
            print("Game Center Leaderboards is shown")
        }
    }

    EGC.showGameCenterChallenges()

    EGC.showGameCenterChallenges {
        (isShow) -> Void in
        if isShow {
            print("Game Center Challenges Is shown")
        }
    }

    EGC.showGameCenterAuthentication()

    EGC.showGameCenterAuthentication { 
        (result) -> Void in
        if result {
            print("Game Center Authentication is open")
        }
    }

    EGC.showCustomBanner(title: "Title", description: "My Description...")

    EGC.showCustomBanner(title: "Title", description: "My Description...") { 
        print("Custom Banner is finish to Show")
    }

    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier")

    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", showBannnerIfCompleted: false)

    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", addToExisting: true)

    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", showBannnerIfCompleted: false ,addToExisting: true)

    if EGC.isAchievementCompleted(achievementIdentifier: "Identifier") {
        print("\n[Easy Game Center]Yes\n")
    } else {
        print("\n[Easy Game Center] No\n")
    }

    if let achievements : [GKAchievement] = EGC.getAchievementCompleteAndBannerNotShowing() {
        for oneAchievement in achievements  {
            print("\n[Easy Game Center] Achievement where banner not show \(oneAchievement.identifier)\n")
        }
    } else {
        print("\n[Easy Game Center] No Achievements with banner not showing\n")
    }

    EGC.showAllBannerAchievementCompleteForBannerNotShowing()

    EGC.showAllBannerAchievementCompleteForBannerNotShowing { 
        (achievementShow) -> Void in
        if let achievementIsOK = achievementShow {
            print("\n[Easy Game Center] Achievement show is \(achievementIsOK.identifier)\n")
        } else {
            print("\n[Easy Game Center] No Achievements with banner not showing\n")
        }
    }

    EGC.getGKAllAchievementDescription {
        (arrayGKAD) -> Void in
        if let arrayAchievementDescription = arrayGKAD {
            for achievement in arrayAchievementDescription  {
                print("\n[Easy Game Center] ID : \(achievement.identifier)\n")
                print("\n[Easy Game Center] Title : \(achievement.title)\n")
                print("\n[Easy Game Center] Achieved Description : \(achievement.achievedDescription)\n")
                print("\n[Easy Game Center] Unachieved Description : \(achievement.unachievedDescription)\n")
            }
        }
    }

    if let achievement = EGC.getAchievementForIndentifier(identifierAchievement: "AchievementIdentifier") {
        print("\n[Easy Game Center] ID : \(achievement.identifier)\n")
    }

    EGC.getTupleGKAchievementAndDescription(achievementIdentifier: "AchievementIdentifier") {            
        (tupleGKAchievementAndDescription) -> Void in
        if let tupleInfoAchievement = tupleGKAchievementAndDescription {
            // Extract tuple
            let gkAchievementDescription = tupleInfoAchievement.gkAchievementDescription
            let gkAchievement = tupleInfoAchievement.gkAchievement
            // The title of the achievement.
            print("\n[Easy Game Center] Title : \(gkAchievementDescription.title)\n")
            // The description for an unachieved achievement.
            print("\n[Easy Game Center] Achieved Description : \(gkAchievementDescription.achievedDescription)\n")
        }
    }

    let progressAchievement = EGC.getProgressForAchievement(achievementIdentifier: "AchievementIdentifier")

    EGC.resetAllAchievements()

    EGC.resetAllAchievements { 
        (achievementReset) -> Void in
        print("\n[Easy Game Center] ID : \(achievementReset.identifier)\n")
    }

    EGC.reportScoreLeaderboard(leaderboardIdentifier: "LeaderboardIdentifier", score: 100)

    EGC.getGKLeaderboard { 
        (resultArrayGKLeaderboard) -> Void in
        if let resultArrayGKLeaderboardIsOK = resultArrayGKLeaderboard {
            for oneGKLeaderboard in resultArrayGKLeaderboardIsOK  {
                print("\n[Easy Game Center] ID : \(oneGKLeaderboard.identifier)\n")
                print("\n[Easy Game Center] Title :\(oneGKLeaderboard.title)\n")
                print("\n[Easy Game Center] Loading ? : \(oneGKLeaderboard.loading)\n")
            }
        }
    }

    EGC.getGKScoreLeaderboard(leaderboardIdentifier: "LeaderboardIdentifier") {
        (resultGKScore) -> Void in
        if let resultGKScoreIsOK = resultGKScore as GKScore? {
            print("\n[Easy Game Center] Leaderboard Identifier : \(resultGKScoreIsOK.leaderboardIdentifier)\n")
            print("\n[Easy Game Center] Date : \(resultGKScoreIsOK.date)\n")
            print("\n[Easy Game Center] Rank :\(resultGKScoreIsOK.rank)\n")
            print("\n[Easy Game Center] Hight Score : \(resultGKScoreIsOK.value)\n")
        }
    }

    EGC.getHighScore(leaderboardIdentifier: "LeaderboardIdentifier") {
        (tupleHighScore) -> Void in
        //(playerName:String, score:Int,rank:Int)?
        if let tupleIsOk = tupleHighScore {
            print("\n[Easy Game Center] Player name : \(tupleIsOk.playerName)\n")
            print("\n[Easy Game Center] Score : \(tupleIsOk.score)\n")
            print("\n[Easy Game Center] Rank :\(tupleIsOk.rank)\n")
        }
    }

    EGC.findMatchWithMinPlayers(2, maxPlayers: 4)

    // Example Struc
    var myStruct = Packet(name: "My Data to Send !", index: 1234567890, numberOfPackets: 1)

    //Send Data
    EGC.sendDataToAllPlayers(myStruct.archive(), modeSend: .Reliable): 4)

    if let players = EGC.getPlayerInMatch() {
        for player in players{
            print(player.alias)
        }
    }

    if let match = EGC.getMatch() {
        print(match)
    }

    EGC.disconnectMatch()

    if EGC.isPlayerIdentified { /* Player identified */ }

    let localPlayer = EGC.getLocalPlayer()

    EGC.getlocalPlayerInformation {
        (playerInformationTuple) -> () in
        //playerInformationTuple:(playerID:String,alias:String,profilPhoto:UIImage?)

        if let typleInformationPlayer = playerInformationTuple {

            self.PlayerID.text = "Player ID : \(typleInformationPlayer.playerID)"
            self.Name.text = "Name : \(typleInformationPlayer.alias)"
            self.PlayerAuthentified.text = "Player Authentified : True"

            if let haveProfilPhoto = typleInformationPlayer.profilPhoto {
                self.PlayerProfil.image = haveProfilPhoto
            }

        }
    }

    if EGC.isConnectedToNetwork { /* You have network */ } 

    EGC.showLoginPage = false

    // If you doesn't want see message Easy Game Center, delete this ligne
    // EGC.debugMode = true