# -*- coding: utf-8 -*-

# Travail TD2
# Groupe : Ismail NADA et Marcellin CHAMBU
# Date : 01/11/2018
############################################################
# Je crée mes trois classes
# En suite je vais y ajouter progressivement les fonctions d'intérêt pour réaliser ce mandat
class Company:
    """ Ma classe parent s'appelle Company
    Elle devra contenir les listes des Drivers, des Cars et la liste contentant les Drivers+Cars.
    """
    def __init__(self, name):
        """ __init__ est le constructeur de Company.
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args:name (str): nom de la compagnie.
        """
        self.name = name.lower()     # je construit une emplacement dans Company pouvant contenir le nom de ma compagnie
        self.listCars = []       # je crée dans Company une liste vide devant contenir les données des voitures
        self.listDrivers = []    # je crée dans Company une liste vide devant contenir les données des chauffeurs
        self.companyfile = []    # je crée dans Company une liste vide devant contenir les données des chauffeurs

    def addCar(self, car):
        """ addCar est une méthode permettant d'ajouter un objet Car dans la liste des voitures.
        Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
        Args: data_cars: liste des voitures.
        """
        self.listCars.append(car)   # permet d'ajouter un objet car dans listCar (la liste des voitures)

    def addDriver(self, driver):
        """addDriver est une méthode permettant d'ajouter un objet Driver dans la liste.
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args:driver (Driver): Chauffeur à ajouter.
        """
        self.listDrivers.append(driver) # permet d'ajouter un objet driver dans la listDriver (la liste des chauffeurs)

    def readCarCsv(self):
        """readCarCsv est une méthode permettant de lire le fichier csv des Cars.
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire.
                """
        import csv
        with open('cars.csv','rb') as csvfile:          # j,importe un fichier csv des voitures
            csvreader = csv.reader(csvfile, delimiter=',')
            for row in csvreader:
                mycar = Car(row[0], row[1], row[2], row[3], row[5], row[6], row[7], row[8]) # je crée un objet mycar
                # qui est une liste tenant en compte que les données pertinentes (sauf row[4]) du fichier csv

                self.addCar(mycar)  # je demande d'ajouter l'objet mycar quand je fais appel à la méthode addCar

    def readDriverCsv(self):
        """readDriverCsv est une méthode permettant de lire le fichier csv des Drivers.
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire.
                """
        import csv
        with open('drivers.csv' ,'rb') as csvfile:       # j,importe un fichier csv des chauffeurs
            csvreader = csv.reader(csvfile, delimiter=',')
            for row in csvreader:
                mydriver = Driver(row[0], row[1], row[2], row[3]) # je crée un objet mydriver
                # qui est une liste contenant les données du fichier csv des chauffeurs
                self.addDriver(mydriver) #je demande d'ajouter l'objet mydriver quand je fais appel à la méthode addDriver

    def CarAndDriverInOneListe(self):
        """CarAndDriverInOneListe est une méthode permettant de créer une liste contenant à la fois les données des
            chauffeurs et des voitures.
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire.
                """
        for k in macompany.listCars:                      # je parcours ma liste des voitures
            for d in macompany.listDrivers:                 # je parcours ma liste des chauffeurs
                if int(k.carId) == int(d.id):                 # si le Id de la voiture correspond à celui du chauffeur
                    macompany.companyfile.append([k.carId, k.lat, k.long, d.firstName,
                                                  d.lastName, k.model, k.make, k.occ, d.sex, k.year, k.adapt])
                    # alors j'ajoute les données des chauffeurs et voitures (construites sous ces index dans les class
                    # Driver et Car)

    def CSVWritter(self):
        """CSVWritter est une méthode permettant d'écrire une liste contenant à la fois les données des
            chauffeurs et des voitures.
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire.
                """
        import csv
        with open('companyfilelist.csv', 'wb') as csvfile:    # je crée un fichier csv companyfilelist à écrire
             csvwriter = csv.writer(csvfile, delimiter=',')
             for d in macompany.companyfile:  # je parcour ma liste contenant les données des chauffeurs et voitures
                 csvwriter.writerow(d[:-3])  # et j'écris dans le fichier csv les lignes sauf les trois dernières qui
                 # contiennent les données non démandées

    def getCarById(self, id):
        """getCarById est une méthode pour retrouver une voiture dans la compagnie
            en fonction de l'identifiant
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args: id (int): identifiant de la voiture
            Returns: un objet Car si on trouve la voiture, sinon None
        """
        # je parcours la liste des voitures
        # quand je trouve celle avec le bon ID
        # je la retourne
        for c in self.listCars:
            if c.id == id:
                return c

    def getDriverByCarId(self, id):
        """getDriverByCarId est une méthode pour retrouver un chauffeur dans la compagnie
            en fonction de l'identifiant de la voiture
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args:id (int): identifiant de la voiture
            Returns: un objet Driver si on trouve le chauffeur, sinon None
        """
        # je parcours les voitures et je retiens uniquement celle
        # dont le ID correspond à celui recherché
        for d in self.listDrivers:
            if d.carId == id:
                return d

    def getNbCarByModel(self):
        """getNbCarByModel est une méthode qui permet de trouver le nombre des voitures selon leur modèle
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire
                    Returns: le nombre des véhicules pour chaque modèle
                """

        modelliste =[]
        for d in macompany.companyfile:
             modelliste.append(d[5])
        model =[]
        for k in modelliste:
             if k in model:
                 pass
             else: model.append(k)

        dico = {}
        for m in macompany.companyfile:
                  modele = m[5]
                  if modele not in dico:
                      dico[modele] = [m[6]]
                  else :
                      dico[modele].append(m[6])

        for r in range(len(model)):

            print "%d véhicules sont de modèle %s %s" % (len(dico[model[r]]), m[6], model[r])

    def getNbCarByYear(self):
        """getNbCarByYear est une méthode qui permet de trouver le nombre des voitures selon leur année de fabrication
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire
                    Returns: le nombre des véhicules pour chaque année de fabrication
                """
        yesarslist =[]
        for d in macompany.companyfile:
            yesarslist.append(d[9])
        year =[]
        for y in yesarslist:
            if y in year :
                pass
            else:
                year.append(y)

        dico = {}
        for m in macompany.companyfile:
            years = m[9]
            if years not in dico:
                dico[years] = [m[6]]
            else:
                dico[years].append(m[6])

        for r in range(len(year)):
            print "%d véhicules sont de l'année %s" % (len(dico[year[r]]), year[r])

    def getNbOfOccupiedCar(self):
        """getNbOfOccupiedCar est une méthode qui permet de trouver le nombre des voitures occupées à un instant t
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire
                    Returns: le nombre des véhicules occupés
                """

        carOcc = []
        for k in self.listCars:
            if int(k.occ) == 1:
                carOcc.append(k)
        return "%d voitures sont occupées en ce moment" % (len(carOcc))

    def getNbOfFreeCar(self):
        """getNbOfFreeCar est une méthode qui permet de trouver le nombre des voitures libres à un instant t
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire
                    Returns: le nombre des véhicules libres
                """
        carfree = []
        for k in self.listCars:
            if int(k.occ) == 0:
                carfree.append(k)
        return "%d voitures sont libres en ce moment" % (len(carfree))
    #
    def getNbCarDrivedByWomenByModel(self):
        """getNbCarDrivedByWomenByModel est une méthode qui permet de trouver le nombre des véhicules classés par modèle
        et dont le chauffeur est une femme
                    Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                    Args:pas nécessaire
                    Returns: un chiffre entier (int)"""
        womendata = []
        for d in macompany.companyfile:
            if d[8] == "F" :
              womendata.append(d)

        modelliste =[]
        for d in womendata:
            modelliste.append(d[5])
        model =[]
        for k in modelliste:
            if k in model:
                pass
            else: model.append(k)

        dico = {}
        for m in womendata:
                 modele = m[5]
                 if modele not in dico:
                     dico[modele] = [m[6]]
                 else :
                     dico[modele].append(m[6])

        for r in range(len(model)):
           print "%d véhicules de modèle %s %s sont conduits par les femmes"  % (len(dico[model[r]]), m[6], model[r])

    def getNbCarDrivedByMenByModel(self):
        """getNbCarDrivedByMenByModel est une méthode qui permet de trouver le nombre des véhicules classés par modèle
                et dont le chauffeur est un homme
                            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                            Args:pas nécessaire
                            Returns: un chiffre entier (int)
        """
        mendata = []
        for d in macompany.companyfile:
           if d[8] == "M":
               mendata.append(d)

        modelliste = []
        for d in mendata:
           modelliste.append(d[5])
        model = []
        for k in modelliste:
           if k in model:
               pass
           else:
               model.append(k)

        dico = {}
        for m in mendata:
           modele = m[5]
           if modele not in dico:
               dico[modele] = [m[6]]
           else:
               dico[modele].append(m[6])

        for r in range(len(model)):
           print "%d véhicules de modèle %s %s sont conduits par les hommes" % (len(dico[model[r]]) , m[6] , model[r])

    def ShuttleStatistics(self):
        """ShuttleStatistics est une méthode qui permet de trouver les statistiques générales sur toute ma flotte.
                            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                            Args:pas nécessaire
                            Returns: les cinq statatistiques précédentes
                            (stat1, stat2, stat3, stat4, stat5 et stat6)
        """

        stat1 = macompany.getNbCarByModel()
        stat2 = macompany.getNbCarByYear()
        stat3 = macompany.getNbOfFreeCar()
        stat4 = macompany.getNbOfOccupiedCar()
        stat5 = macompany.getNbCarDrivedByWomenByModel()
        stat6 = macompany.getNbCarDrivedByMenByModel()

        print stat1
        print stat2
        print stat3
        print stat4
        print stat5
        print stat6

    def CarAndDistance(self):
        """CarAndDistance est une méthode qui calcule la distance de toutes les voitures de la flotte
         par rapport au client.
                            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                            Args:pas nécessaire
                            Returns: Distance en kilomètres entre voiture et client
        """
    #Je fais appel à une librairie mathématique pour le calcul des distances

        from math import radians , sin , cos , sqrt , asin
        distance = []
        for v in macompany.companyfile:
            lat_v = float(v[1])           # latitude de la postition du véhicule (chauffeur)
            lon_v = float(v[2])           # longitude de la postition du client (demandeur de service)

    # je défini aussi, les paramètres de calcul dont j'aurai besoin pour les calculs des distances:
    # les variations de la position du client se feront à ce niveau (lat_ref et lon_ref)
            lat_ref = 45.542969  # latitude de la postition du client (demandeur de service)
            lon_ref = -73.610119  # longitude de la postition du client (demandeur de service)
            R = 6372.8  # Rayon de la Terre en Kilomètres
            dLat = radians(lat_ref - lat_v)  # différence des latitudes en radian
            dLon = radians(lon_ref - lon_v)  # différence des longitudes en radian
            lat_veh = radians(lat_v)  # Je converti la latitude du véhicule en radian
            lat_refe = radians(lat_ref)  # Je converti la latitude du client en radian

            a = sin(dLat / 2) ** 2 + cos(lat_veh) * cos(lat_refe) * sin(dLon / 2) ** 2
            c = 2 * asin(sqrt(a))
            distance.append(R * c)

        voiture_dist = []
        for i in range(len(distance)):
            voiture_dist.append([macompany.companyfile[i][6],macompany.companyfile[i][5], macompany.companyfile[i][7],
                                 macompany.companyfile[i][10], distance[i]])

        return voiture_dist

    def ThreeAnyNearestCars(self):
        """ThreeAnyNearestCars est une méthode qui permet de trouver trois voitures les plus proches du client.
                            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                            Args:pas nécessaire
                            Returns: une liste des trois voitures les plus proches
        """
        car_dist = macompany.CarAndDistance()
        Anyfreecars = []
        for k in car_dist:
             if int(k[2]) == 0 :
                 Anyfreecars.append(k)
        newdata = sorted(Anyfreecars , key=lambda k:k[4])
        newdata2 = newdata[:3]
        return "les trois véhicules les plus proches sont :%s"% (newdata2)

    def ThreeAdaptedNearestCars(self):
        """ThreeAdaptedNearestCars est une méthode qui permet de trouver trois voitures adaptées
         les plus proches du client.
                            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
                            Args:pas nécessaire
                            Returns: une liste des trois voitures adaptées les plus proches
        """
        car_dist = macompany.CarAndDistance()
        Adaptedfreecars = []
        for k in car_dist:
            if int(k[2]) == 0 and int(k[3]) == 1:
                Adaptedfreecars.append(k)
        newdata = sorted(Adaptedfreecars , key=lambda k:k[4])
        newdata2 = newdata[:3]
        return "les trois véhicules adaptés les plus proches sont:" % (newdata2)

class Car:

    """ Car est une classe permettant de gérer l'entité Car.
    Une entité Car permet de conserver les informations de la voiture.
    Une entité Car dispose d'un identifiant, d'un modèle, d'un type, d'une année et d'un kilométrage.
    """

    def __init__(self, carId, make, model, year, longitude, latitude, occupe, adapte ):
        """__init__ est le constructeur de Car.
            Cette méthode va créer un objet Car en mémoire.
            Note:self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args:id (int): identifiant de la voiture, make (str): marque de la voiture, model (str): modèle de la voiture,
                year (int): année de fabrication, longitude (float): longitude de
                localisation du véhicule, latitude (float): latitude de localisation du véhicule, occupe (int) : indique
                si le véhicule est occupé (1) ou libre (0), adapte (int): indique si le véhicule est adapté (1) ou non
                adapté (0)
        """
        self.carId = int(carId)
        self.make = str(make)
        self.model = str(model)
        self.year = int(year)
        self.long = float(longitude)
        self.lat = float(latitude)
        self.occ = int(occupe)
        self.adapt = int(adapte)
class Driver:
    """ Driver est une classe permettant de gérer l'entité Driver.
    Une entité Driver permet de conserver les informations du chauffeur.
    Une entité Driver dispose d'un prénom, d'un nom, d'un genre et d'un identifiant de véhicule.
    """

    def __init__(self, firstName, lastName, sex, id):
        """ __init__ est le constructeur de Driver.
            Cette méthode va créer un objet Driver en mémoire.
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer
                firstName (str): prénom du chauffeur
                lastName (str): nom du chauffeur
                sex (str): genre du chauffeur
        """
        self.firstName = str(firstName)
        self.lastName = str(lastName)
        self.sex = str(sex)
        self.id = int(id)
    def setCarId(self, id):
        """setCarId est une méthode permettant d'attribuer un identifiant de voiture à un Driver.
            Cette méthode va attribuer le id de la voiture.
            Note:`self` est un paramètre qu'il n'est pas nécessaire d'envoyer.
            Args: id (int): identifiant de la voiture
        """
        self.carId = id

############################################################
############################################################
########################################
########################################
########################################
########################################
# je défini le nom de ma compagnie:
macompany = Company("MarDa Trans")
macompany.readCarCsv()
macompany.readDriverCsv()
# macompany.listCars
# mycar=macompany.listCars[5]
# print mycar.carId
macompany.CarAndDriverInOneListe()
# print macompany.listDrivers
# print macompany.companyfile
macompany.CSVWritter()
# print macompany.getNbOfFreeCar()
# print macompany.getNbOfOccupiedCar()

macompany.ShuttleStatistics()
print macompany.ThreeAnyNearestCars()
print macompany.ThreeAdaptedNearestCars()
# print macompany.phoneCallManagerAnyCar()

########################################