# ==================== #
# Nome: Tiago Madeira  #
# Nº de Aluno: 95088   #
#      UC: EDA         #
#     Trabalho 6       #
# ==================== #

''' Modules '''
from csv import reader
import matplotlib.pyplot as plt


''' === Exercício 2 === '''

''' alínea a) - Crie uma subclasse Station, para conter o id da estação e a posição, em graus decimais, da
localização do objeto à superfície da terra '''
class Station:

    __slots__ = "_id_station", "_position"

    def __init__(self, id_station, position):
        self._id_station = id_station    # id da estação
        self._position = position        # posição

    # retorna o id da station
    @property
    def id_station(self):
        return self._id_station

    # retorna a posição da station
    @property
    def position(self):
        return self._position

    def __str__(self):
        return f"Station: {self._id_station}, {self._position}"

    '''Comparação de vértices'''
    def __eq__(self, other):
        if isinstance(other, Station):
            return self._id_station == other.id_station
        return False

    '''Unicidade do elemento'''
    def __hash__(self):
        '''Referência de memória (usada por causa das keys dos dicionários)'''
        return hash(id(self))  # agarra num objeto e transforma num código único

    ''' alínea b) - Crie uma lista de objetos Station a partir do conjunto de dados em lisbon.stations.csv '''
    def read_stations(self):
        f = open("lisbon.stations.csv", "r")  # lê o ficheiro lisbon.stations.csv
        for line in f:
            line_clean = line.strip()  # Remove espaços que estejam no início e no fim de cada linha
            lst = line_clean.split(",")  # cria uma lista com cada item da linha, sendo que o delimiter é a ","
            print(lst)
        f.close()

''' alínea c) - Em Edge, crie uma subclasse Edge_line, para conter a linha de que a conexão faz parte '''
class Edge_line:
    __slots__ = "_origem", "_destino", "_linha", "_stations_lines"

    def __init__(self, origem, destino, linha=None):
        self._origem = origem
        self._destino = destino
        self._linha = linha
        self._stations_lines = []
        with open('lisbon.lines.csv', 'r') as input_file:    # lê o ficheiro lisbon.lines.csv
            station_line = reader(input_file, delimiter=',')
            next(station_line)
            for row in station_line:
                print(row)

    @property
    def origem(self):
        return self._origem

    @property
    def destino(self):
        return self._destino

    @property
    def linha(self):
        return self._linha

    def endpoints(self):
        return self._origem, self._destino

    def opposite(self, v):
        '''return self._destino if v is self._origem else self._origem'''
        if v is self._origem:  # verifica a instância
            return self._destino
        else:
            return self._origem

    def __eq__(self, other):
        """compara element"""
        if isinstance(other, Edge):
            return self._origem == other._origem and self._destino == other._destino and self._peso == other._peso
        return False

    def __str__(self):
        return f"Edge: ({self._origem}, {self._destino})"

    def __hash__(self):
        return hash((id(self._origem), id(self._destino)))  # permite obter a referência de memória do objeto

    def read_connections(self):
        f = open("lisbon.connections.csv", "r")  # lê o ficheiro lisbon.connections.csv
        for line in f:
            line_clean = line.strip()  # Remove espaços que estejam no início e no fim de cada linha
            lst = line_clean.split(",")  # cria uma lista com cada item da linha, sendo que o delimiter é a ","
            print(lst)
        f.close()

    def read_lines(self):
        f = open("lisbon.lines.csv", "r")  # lê o ficheiro lisbon.lines.csv
        for line in f:
            line_clean = line.strip()  # Remove espaços que estejam no início e no fim de cada linha
            lst = line_clean.split(",")  # cria uma lista com cada item da linha, sendo que o delimiter é a ","
            print(lst)
        f.close()

''' alínea e) - Crie uma estrutura de Grafo, i.e., utilize uma das classes do exercício 3) do Módulo 7 '''
class GraphList:

    def __init__(self, directed=False):  # não dirigido
        self._outgoing = {}  # de onde se parte
        self._incoming = {} if directed else self._outgoing  # quando não tem direção o incoming é o mesmo dicionário que o outgoing

    def is_directed(self):
        return self._outgoing is not self._incoming  # se é dirigido

    def vertex_count(self):
        return len(self._outgoing)

    def vertices(self):
        return self._outgoing.keys()

    def edge_count(self):
        # total = sum(len(self._outgoing[key]) for key in self._outgoing)
        total = 0
        for key in self._outgoing:
            value = self._outgoing[key]
            total += len(value)
        return total if self.is_directed() else total // 2

    def edges(self):
        result = set()
        for list_edges in self._outgoing.values():
            for e in list_edges:
                result.add(e)
            # result.update(list_edges)      # união
        return result

    def get_edge(self, u, v):
        edge = Edge(u, v)
        for e in self._outgoing[u]:
            if e == edge:
                return e
        return None

    def degree(self, v, outgoing=True):
        adj = self._outgoing if outgoing else self._incoming
        return len(adj[v])

    def insert_vertex(self, v):
        self._outgoing[v] = ListaL()
        if self.is_directed():
            self._incoming[v] = ListaL()

    def insert_edge(self, a):
        '''TAD exercícios'''
        self._outgoing[a.origem].add(a)
        self._incoming[a.destino].add(a)

    def remove_edge(self, edge):
        for e in self._outgoing[edge.origem]:
            o, d = e.endpoints()
            if o == edge.origem and d == edge.destino:
                self._outgoing[edge.origem].remove(e)
                self._outgoing[edge.destino].remove(e)

''' alínea f) - Crie um procedimento/método para poder visualizar a rede. '''
#fig = plt.figure()
#plt.line(x,y,c=cor)


if __name__ == '__main__':
    s = Station(1, 3.14)
    e = Edge_line(1, 2, 1)