userList=[]
listPlaces = []
listPoliticalParties=[]
listBallotPresidential=[]
votesCantons=[]
listLegislativeElection =[]
finalResults =[]

#This first menu allows to the user to register or log in
def startMenu():
    print("1.Register\n2.Log-in")
    option=input("What do you want to do?:___")
    if option=="1":
        storeInformation()
    elif option=="2":
        login()
    else:
        print("Incorrect opction")
    startMenu()

#This method saves user's data for be registered
def storeInformation():
    id = input("Introduce your ID:")
    fullName = input("Introduce your full name:")
    age = input("Introduce your age:")
    email = input("Introduce your email:")
    password = input("Introduce your password:")
    print("..........................")
    print("Write your type of user:\n1)Administrator\n2)Guest")
    option = input("Introduce your option:_____")
    if option == "1":
        kind = "Administrator"
    elif option == "2":
        kind = "Guest"
    else:
        print("Incorrect option!!\nTry again")
        storeInformation()
    print("Register completed!!!\nNow, you can log in!!\n..........................")
    userRegister(id, fullName, age, email, password, kind)

#This method allows to register the user
def userRegister(id,fullName,age,email,password,kind):
    userNew = {}
    userNew["name"] = fullName
    userNew["id"] = id
    userNew["Kind"] = kind
    userNew["age"] = age
    userNew["email"] = email
    userNew["password"] = password
    userList.append(userNew)

#This method is to start session when the user is registered
def login():
    userId = input("Introduce your ID:____")
    passwordUser = input("Introduce your password:____")
    for user in userList:
        if userId==user["id"] and passwordUser == user["password"]:
            print("You can login!!!\nWelcome!!!\n......................")
            if user["Kind"]=="Administrator":
                administratorsMenu()
            else:
                questions()
    print("You can't login.\nAccount does not exist, you need to create an account\n......................")

#This is the menu for administrators.
def administratorsMenu():
    print("What do you want to do?:____")
    print("1)Territorial Distribution.\n2)Administration of political parties.\n3)Administration of ballot papers.\n4)Results.\n5)Quetions.\n6)Exit.")
    option = input("Introduce your option:_____")
    if option == "1":
        territorialDistribution()
    elif option == "2":
        politicalPartyAdministration()
    elif option == "3":
        ballotsAdministration()
    elif option == "4":
        results()
    elif option == "5":
        questions()
    elif option =="6":
        print("See you later!!")
        startMenu()
    else:
        print("Incorrect opction\nTry again !!")
        administratorsMenu()

#This is the menu for territorial distribution.
def territorialDistribution():
    print("What do you want to do?\n1)Option of province.\n2)Option of cantons.\n3)Option of district.\n4)Go back to the main menu.")
    opcion = input("Introduce your option:_____")
    print("........................")
    if opcion == "1":
        menuInteractProvince()
    elif opcion == "2":
        menuInteractCantons()
    elif opcion == "3":
        menuInterctsDistrits()
    elif opcion=="4":
        administratorsMenu()
    else:
        print("Incorrect Option.\nTry again")
        territorialDistribution()

#This method is the menu for create, modify and delete provinces.
def menuInteractProvince():
    print("What do you want to do?\n1)Create province.\n2)Modify province.\n3)Delete province.\n4)Go back")
    option = input("Introduce your option:_____")
    print("............................")
    if option == "1":
        createProvinceUI()
    elif option == "2":
        modifyProvince()
    elif option == "3":
        deleteProvince()
    elif option == "4":
        territorialDistribution()
    else:
        print("Incorrect option!!")
        menuInteractProvince()

#This method ask for the province's information for create it.
def createProvinceUI():
    nameP = input("Introduce the name of province:______").capitalize()
    cuantityD =int(input("Introduce the deputy's cuantity:______"))
    createProvince(nameP, cuantityD)

#This method add the province at the global list
def createProvince(name, diputes):
    newProvince = {}
    dataP = {}
    newProvince["Name"] = name
    newProvince["Ballot"]={}
    dataP["Diputes"] = diputes
    dataP["Cantons"] = []
    newProvince["Data"] = dataP
    listPlaces.append(newProvince)
    print("Province created!!\nCongratulations!!!\n......................")
    menuInteractProvince()

#This method modify provinces.
def modifyProvince():
    province = input("Introduce the name of the province that you wants to modify:_________").capitalize()
    print("...............................")
    if len(listPlaces) != 0:
        for num in listPlaces:
            if num["Name"] == province:
                menuModifyProvince(num)
        print("The name of the province not exist, try again!!")
        modifyProvince()
    else:
        print("Not exists province, create a province,please.")
        menuInteractProvince()

#This is the menu for modify provinces
def menuModifyProvince(num):
    print("What do you want to do?\n1)Modify name.\n2)Modify cuantity of deputies.\n3)Modify other province.\n4)Go back ")
    option = input("Introduce your option:_____")
    print("...........................")
    if option == "1":
        changeName(num)
    elif option == "2":
        changeCuantityDiputs(num)
    elif option == "3":
        modifyProvince()
    elif option == "4":
        menuInteractProvince()
    else:
        print("Incorrect option!!\nPlease, try again")
        menuModifyProvince(num)

#This method change the name of the province
def changeName(num):
    newName = input("Introduce the new name of the province:______").capitalize()
    num["Name"] = newName
    print("Name of province was changed!!\nCongratulations!!!\n........................")
    menuModifyProvince(num)

#This method change the cuantity of diputes of the province
def changeCuantityDiputs(num):
    nnewCantDiputs = int(input("Introduce the new cuantity of deputies:_____"))
    num["Diputs"] = nnewCantDiputs
    print("Cuantity of deputies was changed!!!\nCongratulations\n..........................")
    menuModifyProvince(num)

#Delete the province
def deleteProvince():
    provinces = input("Introduce the name of the province that you want to eliminate:_____").capitalize()
    if len(listPlaces) != 0:
        for num in listPlaces:
            if num["Name"] == provinces:
                listPlaces.remove(num)
                print("Province was deleted!!!\nCongratulations!!!\n......................")
                menuInteractProvince()
        print("Name of province not exist, try again.")
        deleteProvince()
    else:
        print("There not province, create a province.")
        menuInteractProvince()

#Menu for create, modify and delete cantons.
def menuInteractCantons():
    print("What do you want to do?\n1)Create canton.\n2)Change name of canton.\n3)Delete canton.\n4)Go back.\n.......................")
    opcion = input("Introduce your option:____")
    if opcion == "1":
        checkCreateCanton()
    elif opcion == "2":
        checkModifyCanton()
    elif opcion == "3":
        checkDeletCanton()
    elif opcion == "4":
        territorialDistribution()
    else:
        print("Incorrect option!! Try again.")
        menuInteractCantons()

#Check the name of the province in which you want to create the canton and verify that province exist
def checkCreateCanton():
    province = input("To create canton it needs to introduce the name of the province where it belongs.\n......................\nWrite the name of the province:______").capitalize()
    if len(listPlaces) != 0:
        for num in listPlaces:
            if num["Name"] == province:
                positionC = num["Data"]
                createCanton(positionC)
        print("Name of province not exist, try again.")
        checkCreateCanton()
    else:
        print("There are not province, create a province.")
        menuInteractProvince()

#Create the canton and add the canton to the main list
def createCanton(positionCanton):
    nameC = input("Introduce the name of canton:______").capitalize()
    newCanton = {}
    newCanton["Name"] = nameC
    newCanton["Distrits"] = []
    positionCanton["Cantons"].append(newCanton)
    print("Canton created!!!\nCongratulations!!!\n.........................")
    menuInteractCantons()

#Verify the province where is the canton for then be modified.
def checkModifyCanton():
    if listPlaces != 0:
        nameP = input("Introduce the name of the province where it belongs the canton:______").capitalize()
        print("..............................")
        for num in listPlaces:
            if num["Name"] == nameP:
                positionC = num["Data"]["Cantons"]
                checkCanton(positionC)
        print("Name of province not exist, try again.")
        checkModifyCanton()
    else:
        print("There are not province, create a province.")
        menuInteractProvince()

#Check which is the canton that you want to modify and modify it.
def checkCanton(positionCanton):
    nameC = input("Introduce the name of the canton that you wants to modify:_____").capitalize()
    print(".............................")
    for num in positionCanton:
        if num["Name"] == nameC:
            num["Name"] = input("Introduce the new name of the canton:_____")
            print("Name was changed!!!\nCongratulations!!!\n.........................")
            menuInteractCantons()
    print("Name of canton not exist, try again.")
    checkCanton(positionCanton)
    print("The province don't have any canton, create a canton.")
    menuInteractCantons()

#Verify which is the canton that you want to delete and seek it.
def checkDeletCanton():
    if listPlaces != 0:
        nameP = input("Introduce the name of the province where it belongs the canton:_____").capitalize()
        print("............................")
        for num in listPlaces:
            if num["Name"] == nameP:
                placeC = num["Data"]["Cantons"]
                deleteCanton(placeC)
        print("Name of province not exist, try again.")
        checkDeletCanton()
    else:
        print("There are not province, create a province.")
        menuInteractProvince()

# Delete the cantons
def deleteCanton(placeC):
    if len(placeC)>0:
        nameCanton = input("Introduce the name of the canton that you want to eliminate:_____").capitalize()
        for num in placeC:
            if num["Name"] == nameCanton:
                placeC.remove(num)
                print("Canton was eliminated!!!\nCongratulations\n......................\nNow, what do you want to do?:")
                menuInteractCantons()
        print("The canton's name is incorrect!!!")
        deleteCanton(placeC)
    else:
        print("The province not have any canton, create a canton.")
        menuInteractCantons()

# This is the menu for interact with the districts.
def menuInterctsDistrits():
    print("What do you want to do?\n1)Create distrit.\n2)Modify name.\n3)Delete distrit.\n4)Go back.\n.........................")
    option = input("Introduce your option:_____")
    print("..........................")
    if option == "1":
        locateDistrit()
    elif option == "2":
        changeNameD()
    elif option =="3":
        deleteDistrict()
    elif option=="4":
        territorialDistribution()
    else:
        menuInterctsDistrits()

# This method allows to verify that exist provinces and cantons for create districts
def locateDistrit():
    if len(listPlaces)!= 0:
        nombreP = input("Introduce the name of the province where it belongs the distrit:______").capitalize()
        print("............................")
        for positionProvince in listPlaces:
            if nombreP == positionProvince["Name"]:
                nameCanton = input("Introduce the name of the canton where it belongs the district:______").capitalize()
                print("........................")
                for positionCanton in positionProvince["Data"]["Cantons"]:
                    if nameCanton == positionCanton["Name"]:
                        placeD = positionCanton["Distrits"]
                        createDistritUI(placeD)
                print("The canton's name is incorrect.")
                locateDistrit()
        print("The province not exist, try again.")
        locateDistrit()
    print("There are not province, create a province.")
    menuInteractProvince()

# User's interface for create districts
def createDistritUI(lugarD):
    name = input("Introduce the name of the district that you want to create:_____").capitalize()
    print("..........................")
    createDistrit(lugarD,name)

#Create districts inside the cantons.
def createDistrit(lugarD, name):
    newDistrit = {}
    newDistrit["Name"] = name
    newDistrit["PresidentialVotes"] = []
    newDistrit["LegislativeVotes"] = []
    lugarD.append(newDistrit)
    print("Distrit created!!")
    menuInterctsDistrits()
    createDistrit(lugarD,name)

#This method allows to change the name of the district.
def changeNameD():
    if len(listPlaces)!=[]:
        provinceName = input("Introduce the name of the province where it belongs the district:______").capitalize()
        print(".............................")
        for province in listPlaces:
            if provinceName == province["Name"]:
                if province["Data"]["Cantons"]!=0:
                    cantonName = input("Introduce the name of the canton where it belongs the district:______").capitalize()
                    print(".........................")
                    for canton in province["Data"]["Cantons"]:
                        if cantonName == canton["Name"]:
                            distritName = input("Introduce the name of the district that you want to change:______").capitalize()
                            print("..........................")
                            for distrit in canton["Distrits"]:
                                if distrit["Name"]==distritName:
                                    newName=input("Write the new name of the district:______").capitalize()
                                    distrit["Name"]=newName
                                    print("The district was changed!!!\nCongratulations!!!")
                                    print(".............................")
                                    menuInterctsDistrits()
                            print("District's name is incorrect!!Try again, please")
                            changeNameD()
                    print("Canton's name is incorrect!!")
                    changeNameD()
                print("There are not cantons in the province")
        print("The province not exist\nTry again")
        changeNameD()
    else:
        print("There are not province.")
        menuInteractProvince()

#This function allows to delete a distric if user wants.
def deleteDistrict():
    eliminatedistric=input("Introduce the name of the district that you want to delete:______").capitalize()
    print(".........................")
    for province in listPlaces:
        for canton in province["Data"]["Cantons"]:
            for district in canton["Distrits"]:
                if district["Name"]==eliminatedistric:
                    canton["Distrits"].remove(district)
                    print("The district was deleted!!!\nCongratulations!!!\n...........................")
                    menuInterctsDistrits()
        print("The district not exist.\nTry again.")
        deleteDistrict()
    menuInterctsDistrits()

# This is the menu for political parties administration.
def politicalPartyAdministration():
    print("What do you want to do?:\n1)Create political party.\n2)Modify political party.\n3)Delete political party.\n4)Go back to the main menu.\n......................")
    option = input("Introduce your option:____")
    print("........................")
    if option == "1":
        createPartyUI()
    elif option == "2":
        modifyParty()
    elif option == "3":
        deleteParty()
    elif option == "4":
        administratorsMenu()

# Create political parties(Graphics interface).
def createPartyUI():
    nameP = input("Introduce the initials of the political party:_____").upper()
    dateFundation = int(input("Introduce date's fundation of political party:_____"))
    colorP = input("Introduce the color of the political party:_____")
    ideology = input("Introduce the ideology of the political party:_____")
    createParty(nameP, dateFundation, colorP, ideology,votes=0)

#Create political parties(Logical interface).
def createParty(name, date, color, ideology,votes):
    dataP = {}
    newParty = {}
    newParty["NameP"] = name
    newParty["Votes"]=0
    dataP["Date"] = date
    dataP["Color"] = color
    dataP["Ideology"] = ideology
    newParty["Data"] = dataP
    listPoliticalParties.append(newParty)
    print("Political party was added!!!\nCongratulations!!!\n......................")
    politicalPartyAdministration()

# Modify political parties menu.
def modifyParty():
    print("What do you want to do?:\n1)Modify political party.\n2)Go back.")
    opcion = input("Introduce your option:_____")
    print("............................")
    if opcion == "1":
        nameP = input("Introduce the initials of the political party that you want to modify:______").upper()
        print("..........................")
        i = 0
        while i <= len(listPoliticalParties):
            if nameP == listPoliticalParties[i]["NameP"]:
                menuModifyParty[i]
            i += 1
        print("The name of the political party is incorrect or does not exist.")
        modifyParty()
    elif opcion == "2":
        politicalPartyAdministration()

#This is the menu for modify information of the political party.
def menuModifyParty(position):
    print("1)Modify the name. \n2)Modify fundation's date.\n3)Modify the color. \n4)Modify th ideology.\n5)Go back.")
    option = input("Introduce your option:_____")
    print("...........................")
    if option == "1":
        newName = input("Introduce the new name of the political party:_____").upper()
        listPoliticalParties[position]["Name"] = newName
        menuModifyParty(position)
    elif option == "2":
        newDate = int(input("Introduce the new foundation's date of the political party:_____"))
        print("..............................")
        listPoliticalParties[position]["Data"]["Date"] = newDate
        menuModifyParty(position)
    elif option == "3":
        newColor = input("Introduce the new color of the political party:_____")
        print("...............................")
        listPoliticalParties[position]["Data"]["Color"] = newColor
        menuModifyParty(position)
    elif option == "4":
        newIdeology = input("Introduce the new ideology of the political party:_____")
        print("............................")
        listPoliticalParties[position]["Data"]["Ideology"] = newIdeology
        menuModifyParty(position)
    elif option == "5":
        politicalPartyAdministration()

#Delete the political party.
def deleteParty():
    if listPoliticalParties != []:
        nameParty = input("Introduce the initials of the political party:_____").upper()
        print("..............................")
        for party in listPoliticalParties:
            if nameParty == party["NameP"]:
                print("Party was deleted!!\nCongratulations!!!\n........................")
                politicalPartyAdministration()
        print("Party's name is incorrect!!\nTry again\n........................")
        deleteParty()
    print("There are not political parties")
    politicalPartyAdministration()

#Administration of ballots Menu
def ballotsAdministration():
    print("What do you want to do?\n1)Create Ballot.\n2)Delete Ballot\n3)Modify Ballot.\n4)Go back.")
    option = input("Introduce your option:_____")
    print("...........................")
    if option == "1":
        if len(listPoliticalParties) != 0:
            createBallotsUI()
        print("There are not political parties.\nYou need to create a political party\n.......................")
        politicalPartyAdministration()
    elif option == "2":
        deleteBallots()
    elif option == "3":
        modifyBallots()
    elif option == "4":
        administratorsMenu()
    else:
        ballotsAdministration()

#This method calls the funtion of create ballots
def createBallotsUI():
    listPoliticalPartiesBallots = []
    createBallots(listPoliticalPartiesBallots)

#This method add political parties to the ballots, legislative or presidential. Also print the list of political parties that exist.
def createBallots(listPoliticalPartiesBallots):
    print("Do you want to add a political party to the ballot?")
    print("List of political parties:")
    for nameParty in listPoliticalParties:
        print(nameParty["NameP"])
    print("1)Yes\n2)No")
    option = input("Introduce your option:")
    print(".........................")
    if option == "1":
        namePartyAdd = input("Introduce the name of the political party:_____").upper()
        for politicalParty in listPoliticalParties:
            if namePartyAdd == politicalParty["NameP"]:
                listPoliticalPartiesBallots.append(politicalParty)
                print(listPoliticalPartiesBallots)
                createBallots(listPoliticalPartiesBallots)
        print("Political party not exist!!! Try again")
        createBallots(listPoliticalPartiesBallots)
    elif option == "2":
        if len(listPoliticalPartiesBallots) != 0:
            print("What type of ballot is?")
            print("1)Presidential\n2)Legislative")
            option2 = input("Introduce your option:____")
            print(".........................")
            if option2 == "1":
                listBallotPresidential.append(listPoliticalPartiesBallots)
                print("Political ballot was created!!!\nCongratulations!!!\n..........................")
                ballotsAdministration()
            elif option == "2":
                print("What province do you want to add to the ballot?")
                nameProvince = input("Introduce the name of the province:_____").capitalize()
                for province in listPlaces:
                    if nameProvince == province["Name"]:
                        province["Ballot"] = listPoliticalPartiesBallots
                        print("Political ballot was created!!!\nCongratulations!!!\n........................")
                        ballotsAdministration()
                else:
                    print("Province not exist!! Try again\n.......................")
                    createBallots(listPoliticalPartiesBallots)
        print("You need to add at least a political party to the ballot.\nAdd a political party to the ballot, please.")
        createBallotsUI()
    else:
        print("Incorrect option!!! Try again\n..........................")
        createBallotsUI()

#This method allows to modify the ballots.
def modifyBallots():
    modifyballot=input("What kind of ballot do you want to modify?\n1)Legislative\n2)Presidential\n3)Go back\nChoose your option:____")
    print("..........................")
    if modifyballot=="1":
        print("What do you want to do?:_____\n.............................")
        option=input("1)Add more political parties to the ballot\n2)Delete political parties of the ballot\n3)Go back\n.............................\nIntroduce your option:_____")
        if option=="1":
            place=input("Write the name of the province where is the ballot:_____").capitalize()
            print("...........................")
            for province in listPlaces:
                if place==province["Name"]:
                    if province["Ballot"] != []:
                        newBallot=province["Ballot"]
                        addPoliticalPartytoBallot(newBallot)
                    else:
                        print("Ballot not exist in the province. Please,create a ballot\n.......................")
                        ballotsAdministration()
            print("Name of province is incorrect.Try again!!")
            modifyBallots()
        elif option=="2":
            deletePoliticalPartyBallot()
        elif option == "3":
            ballotsAdministration()
        else:
            print("Incorrect option.Try again!!")
            modifyBallots()
    elif modifyballot=="2":
        if listBallotPresidential!= []:
            modifyPresidencialBallot()
        else:
            print("Presidential ballot not exist. Please, create a ballot")
            ballotsAdministration()
    elif modifyballot=="3":
        ballotsAdministration()
    else:
        print("Empty list")

#This method allows to add political parties to the legislative ballot.
def addPoliticalPartytoBallot(newBallot):
    print("Do you want to add political parties to the ballot?")
    print("List of political parties is:")
    for nameParty in listPoliticalParties:
        print(nameParty["NameP"])
    print("1)Yes\n2)No")
    option = input("Introduce your option:_____")
    if option == "1":
        namePartyAdd = input("Introduce the initials of the political party:").upper()
        for politicalParty in listPoliticalParties:
            if namePartyAdd == politicalParty["NameP"]:
                print("Political party was removed!!\nCongratulations!!!\n......................")
                newBallot.append(politicalParty)
                modifyBallots()
        print("Political party not exist.Try again\nWrite the initials of the political party.")
    elif option == "2":
        modifyBallots()
    else:
        print("Incorrect option\nTry again!!\n.......................")

#This method allows to remove political parties of the legislative ballot.
def deletePoliticalPartyBallot():
    place = input("Write the name of the province where is the ballot:_____").capitalize()
    print(".........................")
    for province in listPlaces:
        if place == province["Name"]:
            if province["Ballot"]!=[]:
                print("List of political parties is:")
                for nameParty in province["Ballot"]:
                    print(nameParty["NameP"])
                delete = input("Write the initials of the political party that you want to eliminate:_____").upper()
                for party in province["Ballot"]:
                    if delete==party["NameP"]:
                        province["Ballot"].remove(party)
                        print("Political party was eliminated\nCongratulations!!!\n........................")
                        modifyBallots()
            else:
                print("Ballot not exist in the province\nPlease, you need to create a ballot")
                ballotsAdministration()
    print("Name of province is incorrect.\nTry again")
    modifyBallots()

#This method allows to delete as much as the legislative ballot like the presidential ballot
def deleteBallots():
    print("What kind of ballot do you want to delete?\n1)Presidential.\n2)Legislative.")
    option = input("Choose your option:___")
    print("...........................")
    if option =="1":
        if len(listBallotPresidential) ==[]:
            print("There are not presidential ballot.\nYou need to create a presidential ballot.\n........................")
            ballotsAdministration()
        else:
            print("There are not presidential ballot.\nYou need to create a presidential ballot.\n........................")
            ballotsAdministration()
            listBallotPresidential.clear()
            print("Ballot was deleted!!\nCongratulations!!!\n........................")
            ballotsAdministration()
    elif option == "2":
         print("For delete legislative ballot, you need to write the name of the province where is the ballot.")
         nameProvince=input("Write the name of the province where is the ballot:______").capitalize()
         for province in listPlaces:
                 if nameProvince == province["Name"]:
                     if len(province["Ballot"]) != 0:
                         province["Ballot"] = []
                         print("Delete ballot!!\nCongratulations!!!\n...........................")
                         print(listPlaces)
                         ballotsAdministration()
                     else:
                         print("There are not ballot in the province.\nCreate a ballot, please", province["Name"])
                         ballotsAdministration()
         print("Province not exist.Try again\n..........................")
         deleteBallots()
    else:
        print("Incorrect option.Try again.\n..........................")
        ballotsAdministration()

#This method allows to modify the presidential ballot.
def modifyPresidencialBallot():
    print("What do you want to do?:\n........................")
    option = input("1)Add more political parties to the ballot\n2)Delete political parties of the ballot\n3)Go back\nIntroduce your option:_____")
    print("...............................")
    if option == "1":
        print("List of political parties is:")
        for nameParty in listPoliticalParties:
            print(nameParty["NameP"])
        namePartyAdd = input("Introduce the initials of the political party:_____").upper()
        for politicalParty in listPoliticalParties:
            if namePartyAdd == politicalParty["NameP"]:
                listBallotPresidential.append(politicalParty)
                print(listBallotPresidential)
                print("Political party was added successfully\nCongratulations!!!\n.......................")
                modifyBallots()
        print("Party's name is incorrect!! Try again, please.\n..........................")
    if option=="2":
        print("List of political parties is:")
        for nameParty in listBallotPresidential:
            print(nameParty["NameP"])
        politicalParty = input("Write the initials of the political party for eliminate it:_____").upper()
        for party in listBallotPresidential:
            if politicalParty==party["NameP"]:
                listBallotPresidential.remove(party)
                print("Political party was eliminated successfully\nCongratulations!!!\n..........................")
                modifyBallots()
    else:
        print("Incorrect option.Try again, please.")
        modifyPresidencialBallot()

#Menu of results. This method allows to edit the presidential results or legislative results..
def results():
    print("What do you want to do?:\n1)To edit presidential results.\n2)To edit legislative results.\n3)Go back.\n........................")
    option = input("Introduce your option:_____")
    print(".............................")
    if option == "1":
        if listBallotPresidential != []:
            if len(listPlaces)!= 0:
                print("It's necessary to save the voting results by district.")
                nameProvince = input("Write the name of the province where the district is located:_____").capitalize()
                for province in listPlaces:
                    if province["Name"] == nameProvince:
                        if province["Data"]["Cantons"] != 0:
                            nameCanton = input("Write the name of the canton where the district is located:_____").capitalize()
                            for canton in province["Data"]["Cantons"]:
                                if nameCanton == canton["Name"]:
                                    if canton["Distrits"] != 0:
                                        nameDistrict = input("Write the name of the district that you want to edit the results:_____").capitalize()
                                        for district in canton["Distrits"]:
                                            if nameDistrict == district["Name"]:
                                                    presidentialResults(district)
                                        print("The district's name is incorrect.Try again, please!!.")
                                        results()
                                    print("There are not districts in the canton.\n.......................")
                                    results()
                            print("The canton's name is incorrect.\nTry again, please!!\n.......................")
                            results()
                        print("There are not cantons in the province.\nTry again, please\n......................")
                        results()
                print("The province's name is incorrect\nTry again.")
                results()
            print("There are not province\nYou need to create a province.\n..........................")
            results()
        print("There are not presidential ballot.")
        results()
    elif option =="2":
        if len(listPlaces) != 0:
            print("It is necessary to save the voting results by district.")
            nameProvince = input("Write the name of the province where the district is located:_____").capitalize()
            for province in listPlaces:
                if province["Name"] == nameProvince:
                    if province["Ballot"]!=[]:
                        if province["Data"]["Cantons"] != 0:
                            nameCanton = input("Write the name of the canton where the district is located:_____").capitalize()
                            for canton in province["Data"]["Cantons"]:
                                if nameCanton == canton["Name"]:
                                    if canton["Distrits"] != 0:
                                        nameDistrict = input("Write the name of the district that you want to edit the results:_____").capitalize()
                                        for district in canton["Distrits"]:
                                            if nameDistrict == district["Name"]:
                                                legislativeResults(province,district)
                                        print("The district's name is incorrect\nTry again, please.\n....................")
                                        results()
                                    print("There are not districts in the canton.\n......................")
                                    results()
                            print("The canton's name is incorrect.\nTry again, please!!\n.....................")
                            results()
                        print("There are not cantons in the province.\n......................")
                        results()
                    print("There are not legislative ballot.\n........................")
                    results()
            print("The province's name is incorrect\nTry again, please!!\n.....................")
            results()
        print("There are not province\nYou need to create a province.\n..........................")
        results()
    elif option == "3":
        administratorsMenu()
    else:
        print("Incorrect option!!!\n Try again.")
        results()

#Edit the results of the presidentials votes.
def legislativeResults(province,district):
    newResults = {}
    print("The ballot is:")
    for party in province["Ballot"]:
        cantVotes = int(input("How many votes for "+ party["NameP"]+" ?:_____"))
        newResults[party["NameP"]]= cantVotes
    district["LegislativeVotes"].append(newResults)
    results()

#Edit the results of the legislatice votes.
def presidentialResults(district):
    print("The ballot is:")
    for party in listBallotPresidential[0]:
        newResults = {}
        cantVotes = int(input("How many votes for " + party["NameP"] + " ?:_____"))
        newResults["Name"] = party["NameP"]
        newResults["Votes"] = cantVotes
        district["PresidentialVotes"].append(newResults)
    results()

#Menu of questions
def questions():
    votesCantons.clear()
    print("What do you want to do?\n1) National results of the presidential election.\n2) Provincial results of the presidential election\n3) Cantonal results of the presidential election\n4) District results of the presidential election\n5) Results of the legislative election\n6) Exit")
    option = input("Introduce your option:______")
    print("..........................")
    if option =="1":
        nationalResultsElectionsUI()
    elif option =="2":
        presidentialProvince()
    elif option == "3":
        presidentialCantons()
    elif option == "4":
        presidentialDistricts()
    elif option== "5":
        legislativeElection()
    elif option=="6":
        print("See you later!!")
        exit()
    else:
        print("Incorrect option!!!! Try again, please\n........................")

#Locate the canton in the list, seek it and verify in case that canton not exist or misspelled.
def presidentialCantons():
    if len(listPlaces) !=0:
        nameProvince = input("Introduce the province's name:_____").capitalize()
        for province in listPlaces:
            if province["Name"] == nameProvince:
                if province["Data"]["Cantons"]!=0:
                    nameCanton = input("Introduce the canton's name:_____").capitalize()
                    for canton in province["Data"]["Cantons"]:
                        if nameCanton == canton["Name"]:
                            cantonVotes = canton["Distrits"]
                            presidentialCantonsUI(cantonVotes)
                    print("Canton's name is incorrect\nTry again, please.\n..........................")
                    questions()
                print("There are not cantons")
                questions()
        print("The province's name is incorrect\nTry again, please.\n.........................")
        questions()
    print("There are not provinces.")
    questions()

#Add to the global list the political parties that exist.
def presidentialCantonsUI(canton):
    for nameParty in listBallotPresidential[0]:
        party ={}
        party["Name"]= nameParty["NameP"]
        party["Votes"]= 0
        votesCantons.append(party)
    addVotesCantons(canton)

#With the help of the previous method,this method sum all the votes of every party, saved in the global list previous mentioned.
def addVotesCantons(canton):
    for district in canton:
        for party in district["PresidentialVotes"]:
            for partyLocated in votesCantons:
                if partyLocated["Name"] == party["Name"]:
                    partyLocated["Votes"] += party["Votes"]
    printResultsPresidentialCantons()

#Print the results of the canton's elections.
def printResultsPresidentialCantons():
    totalVotes=0
    print("The cuantity of votes are:")
    print("Party's name:      Votes cuantity:")
    for party in votesCantons:
        print(party["Name"] + "                    " + str(party["Votes"]))
        totalVotes+= party["Votes"]
    print("Total Votes:           " + str(totalVotes) + "\n.......................")
    print("The percentage are:")
    print("Party's name:      Percentage:")
    for party in votesCantons:
        percentageParty = (party["Votes"] * 100) / totalVotes
        print(party["Name"] + "                  " + str(percentageParty) + "%")
    print(".......................")
    questions()

# Ask for the district for know the results.
def presidentialDistricts():
    if len(listPlaces)!=0:
        nameProvince = input("Introduce the province's name:______").capitalize()
        print(".........................")
        for province in listPlaces:
            if province["Name"] == nameProvince:
                if province["Data"]["Cantons"]!=0:
                    nameCanton = input("Introduce the canton's name:_____")
                    for canton in province["Data"]["Cantons"]:
                        if nameCanton == canton["Name"]:
                            if canton["Distrits"]!=0:
                                nameDistrict = input("Introduce the district's name:______").capitalize()
                                for district in canton["Distrits"]:
                                    if nameDistrict == district["Name"]:
                                        presidentialVotes = district["PresidentialVotes"]
                                        resultPresidentialDistrictsUI(presidentialVotes)
                                print("The district's name is incorrect\nTry again\n........................")
                                questions()
                            print("There are not districts in the canton\nTry again\n...........................")
                            questions()
                    print("The canton's name is incorrect")
                    questions()
                print("There are not cantons in the province\nTry again\n.......................")
                questions()
        print("The province's name is incorrect")
    print("There are not province. You need to create a province.\nTry again\n........................")
    questions()

#Print the votes of every political party by district and print the total votes.
def resultPresidentialDistrictsUI(presidentialVotes):
    totalVotes =0
    print("The cuantity of votes are:")
    print("Party's name:      Votes cuantity:")
    for party in  presidentialVotes:
        print(party["Name"]+"                    "+str(party["Votes"]))
        totalVotes+= party["Votes"]
    print("Total Votes:           " +str(totalVotes)+"\n.......................")
    print("The percentage are:")
    print("Party's name:      Percentage:")
    for party in presidentialVotes:
        percentageParty = (party["Votes"]*100)/totalVotes
        print(party["Name"]+"                  "+str(percentageParty)+"%")
    questions()

#Add to the global list the political parties that exist.
def nationalResultsElectionsUI():
    for nameParty in listBallotPresidential[0]:
        party ={}
        party["Name"]= nameParty["NameP"]
        party["Votes"]= 0
        votesCantons.append(party)
    addVotesCountry()

#Sum all the votes of every political party saved in the global list.
def addVotesCountry():
    for province in listPlaces:
        for canton in province["Data"]["Cantons"]:
            for district in canton["Distrits"]:
                for party in district["PresidentialVotes"]:
                    for partyLocated in votesCantons:
                        if partyLocated["Name"] == party["Name"]:
                            partyLocated["Votes"] += party["Votes"]
    printnationalResultsElections()

#Print the results of the nationals elections.
def printnationalResultsElections():
    totalVotes = 0
    print("The cuantity of votes are:")
    print("Party's name:      Votes cuantity:")
    for party in votesCantons:
        print(party["Name"] + "                    " + str(party["Votes"]))
        totalVotes += party["Votes"]
    print("Total Votes:           " + str(totalVotes) + "\n.......................")
    print("The percentage are:")
    print("Party's name:      Percentage:")
    for party in votesCantons:
        percentageParty = (party["Votes"] * 100) / totalVotes
        print(party["Name"] + "                  " + str(percentageParty) + "%")
    print(".....................")
    questions()

#Locate the province for add the votes to the province
def presidentialProvince():
    if listPlaces != []:
        nameProvince = input("Introduce the province's name:_____").capitalize()
        for province in listPlaces:
            if province["Name"]==nameProvince:
                addVotesProvinceListUI(province)
        print("Province's name is incorrect\nTry again\n..........................")
        presidentialProvince()
    print("There are not province. You need to create a province\nTry again\n...........................")
    questions()

#Create a dictionary in the general list, also named votesCantos, where the votes will saved.
def addVotesProvinceListUI(province):
    for nameParty in listBallotPresidential[0]:
        party = {}
        party["Name"] = nameParty["NameP"]
        party["Votes"] = 0
        votesCantons.append(party)
    addVotesProvinceList(province)

#Add the canton's votes to the global list of votes.
def addVotesProvinceList(province):
    for canton in province["Data"]["Cantons"]:
        for district in canton["Distrits"]:
            for party in district["PresidentialVotes"]:
                for partyLocated in votesCantons:
                    if partyLocated["Name"] == party["Name"]:
                        partyLocated["Votes"] += party["Votes"]
    printResultsPresidentialProvince()

#Print the results of the presidential election.
def printResultsPresidentialProvince():
    totalVotes=0
    print("The cuantity of votes are:")
    print("Party's name:           Cuantity of votes:")
    for party in votesCantons:
        print(party["Name"]+"                    "+str(party["Votes"]))
        totalVotes+=party["Votes"]
    print("Total Votes:           "+str(totalVotes)+"\n...........................")
    print("The percentage are:")
    print("Party's name:      Percentage:")
    for party in votesCantons:
        percentageParty = (party["Votes"] * 100) / totalVotes
        print(party["Name"] + "                  " + str(percentageParty) + "%")
    questions()

#This method add a province to the legislative global list with the most important information.
def legislativeElection():
    for province in listPlaces:
        newResults={}
        newResults["Province"]=province["Name"]
        newResults["Diputs"]= province["Data"]["Diputes"]
        totalParties(province,newResults)
    resultsLegislativeElection()

#Create a list with the political parties of the ballot in the province and the results of the votes are added him.
def totalParties(province,newResults):
    votesProvince=[]
    for nameParty in province["Ballot"]:
        party = {}
        party["Name"] = nameParty["NameP"]
        party["Votes"] = 0
        party["Cont"]=0
        votesProvince.append(party)
    addVotesToList(votesProvince,province,newResults)

#It adds all the votes of the political party and adds the provinces with the most important information to the global list.
def addVotesToList(votesProvince,province,newResults):
    for canton in province["Data"]["Cantons"]:
        for district in canton["Distrits"]:
            for party in district["LegislativeVotes"]:
                for partyLocated in votesProvince:
                    if partyLocated["Name"] == party[partyLocated["Name"]]:
                        partyLocated["Votes"] += party["Votes"]
    newResults["Parties"]=votesProvince
    listLegislativeElection.append(newResults)

#Edit the list mentioned in the previous functions with the number of deputies that each political party can take.
def resultsLegislativeElection():
    print(listLegislativeElection)
    for province in listLegislativeElection:
        totalVotes=0
        for party in province["Parties"]:
            totalVotes+=party["Votes"]
        originalDeputy = province["Diputs"]
        ratio = totalVotes/province["Diputs"]
        while province["Diputs"]>0:
            i=0
            while i<len(province["Parties"]) and province["Diputs"]!=0:
                if province["Parties"][i]["Votes"]>=ratio:
                    province["Parties"][i]["Cont"]+=1
                    province["Parties"][i]["Votes"]-=ratio
                    province["Diputs"]-=1
                else:
                    i+=1
            if province["Diputs"] !=0 :
                if ratio == (totalVotes/originalDeputy)/2:
                    nameP= definWinnerLastDeputy(province)
                    for party in province["Parties"]:
                        if nameP ==party["Name"]:
                            party["Cont"]+=1
                            province["Diputies"]-=1
                elif ratio == totalVotes/originalDeputy:
                    ratio= ratio/2
    printFinalsResultsProvintial()

#Determine which match the last candidate takes by the simple majority method.
def definWinnerLastDeputy(province):
        i=0
        mayor=0
        while i< len(province["Parties"]):
            if mayor==0:
                mayor= province["Parties"][i]["Votes"]
                i+=1
            if province["Parties"][i]["Votes"]>mayor:
                mayor= provine[i]["Votes"]
                i+=1
            i+=1
        for party in province["Parties"]:
            if party["Votes"]==mayor:
                return (party["Name"])

#Prints the final result of the legislative elections, by province.
def printFinalsResultsProvintial():
    print("The results are:")
    for province in listLegislativeElection:
        print("......................\n"+province["Province"])
        print("Party's name:           Cuantity of deputies:")
        for party in province["Parties"]:
            print(party["Name"]+"                               "+str(party["Cont"]))
    addResultsLegislativeConformation()

#It seeks the political parties to add the deputies' cuantity obtained for every party in the global list.
def addResultsLegislativeConformation():
    for province in listLegislativeElection:
        for party in province["Parties"]:
            createListTemporal(party)
    addDeputes()

#Add political parties to the global  list and verify that the political parties does not be repeated.
def createListTemporal(party):
    if votesCantons==[]:
            newParty={}
            newParty["Name"]=party["Name"]
            newParty["Cont"]=0
            votesCantons.append(newParty)
    elif votesCantons!=0:
        can = True
        for nameParty in votesCantons:
            if nameParty["Name"]==party["Name"]:
                can= False
        if can!=False:
            newParty = {}
            newParty["Name"] = party["Name"]
            newParty["Cont"] = 0
            votesCantons.append(newParty)

# Add deputies to the global list in position of parties:
def addDeputes():
    for province in listLegislativeElection:
        for party in province["Parties"]:
            for partyLocated in votesCantons:
                if partyLocated["Name"] == party["Name"]:
                    partyLocated["Cont"] += party["Cont"]
    printFinalsResultsLegislativeConformation()

# Print the constitution of the legislative assembly.
def printFinalsResultsLegislativeConformation():
    print("....................\n....................")
    print("The constitution of Legislative Assembly is:")
    print("Party's name:           Cuantity of deputies:")
    for party in votesCantons:
        print(party["Name"] + "                               " + str(party["Cont"]))
    print("....................\n....................")
    questions()

startMenu()