import csv
import json

class Vertex(object):
    def __init__(self, value=None,lat=None,long=None):
        self.__value = value
        self.__edges = [] #List of edge keys connected to vertex
        self.__lat = lat
        self.__long = long

    def getValue(self):
        return self.__value

    def setValue(self,value):
        self.__value = value

    def getEdges(self):
        return self.__edges

    def addEdge(self,name):
        self.__edges.append(name)

    def removeEdge(self,name):
        self.__edges.remove(name)

    def getLat(self):
        return self.__lat

    def setLat(self,lat):
        self.__lat = lat

    def getLong(self):
        return self.__long

    def setLong(self,long):
        self.__long = long

class Edge(object):
    def __init__(self,sA,sB,value=None,weight=None):
        self.__vertices=[sA,sB] #keys of two vertices
        self.__value=value
        self.__weight=weight

    def getVertices(self):
        #Returns keys of vertices
        return self.__vertices

    def getValue(self):
        return self.__value

    def setValue(self):
        self.__value = value

    def getWeight(self):
        return self.__weight

    def setWeight(self):
        self.__weight = weight

class Graph(object):
    def __init__(self):
        #Creates empty graph
        self.__graphDict = {} #Dict of all vertices
        self.__graphEdges = {} # empty dict of all edges

    def getVertices(self):
        #returns dict of all vertices
        return self.__graphDict

    def getVerticesList(self):
        #returns list of the keys of the vertices
        return list(self.__graphDict.keys())

    def getVertex(self,key):
        #returns object of vertex at given key
        if key in self.__graphDict:
            return self.__graphDict[key]
        else: #If vertex does not exist
            raise KeyError('Vertex "'+key+'" does not exist')

    def getEdges(self,vertex=None):
        #retruns dict of edges of a vertex, if no vertex given returns all
        if vertex == None:
            return self.__graphEdges
        else:
            if vertex in self.__graphDict:
                keys = self.__graphDict[vertex].getEdges() #Gets list of keys from vertex object
                out = {}
                for key in keys: #Adds object of edges for each key to output dict
                    out[key] = self.__graphEdges[key]
                return out
            else: #If vertex does not exist
                raise KeyError('Vertex "'+vertex+'" does not exist')

    def getEdgesList(self,vertex=None):
        #returns list of keys of edges of vertex, if no vertex given returns all
        if vertex==None:
            return list(self.__graphEdges.keys())
        else:
            if vertex in self.__graphDict:
                return self.__graphDict[vertex].getEdges() #Gets list of keys from vertex object
            else: #If vertex does not exist
                raise KeyError('Vertex "'+vertex+'" does not exist')

    def getNeighbours(self,vertex):
        #returns list of neighbours of vertex
        edges = self.__graphDict[vertex].getEdges()
        output = [] #Empty list of neighbours
        for key in edges:
            edge = self.__graphEdges[key]
            vertices = edge.getVertices() #Get keys of edge
            if vertices[0] != vertex: #Checks which is not source
                output.append(vertices[0])
            else:
                output.append(vertices[1])
        return output

    def isAdjacent(self,one,two):
        #Returns True if adjacent
        neigh = self.getNeighbours(one)
        if two in neigh:
            return True
        else:
            return False

    def addVertex(self,name,value=None,lat=None,long=None):
        #Adds an empty vertex to the graph
        if name in self.__graphDict: #If vertex already exists
            raise NameError('Vertex already exists')
        else:
            self.__graphDict[name] = Vertex(value,lat,long)

    def removeVertex(self,vertex):
        #Removes vertex and connected edges
        #   Removes edges
        edges = self.getNeighbours(vertex)
        for key in edges:
            removeEdge(vertex,key)
        self.__graphDict.pop(vertex) #Removes vertex

    def addEdge(self, sa, sb,value=None,weight=None):
        if sa in self.__graphDict and sb in self.__graphDict: #Check if vertices exist
            name = (str(sa)+'-'+str(sb)) #Creates key in format vertex1-vertex2
            edge = Edge(sa, sb,value,weight) #Creates edge
            self.__graphEdges[name]=edge #Adds edge to general dictionary
            self.__graphDict[sa].addEdge(name) #Adds edge key to vertex1
            self.__graphDict[sb].addEdge(name) #Adds edge key to vertex2
        elif sa in self.__graphDict:
            raise KeyError('Vertex '+sb+' does not exist')
        elif sb in self.__graphDict:
            raise KeyError('Vertex '+sa+' does not exist')
        else:
            raise KeyError('Vertices '+sa+' and '+sb+' do not exist')

    def removeEdge(self, sa, sb):
        if sa in self.__graphDict and sb in self.__graphDict: #Check if vertices exist
            name = (str(sa)+'-'+str(sb)) #Creates key in format vertex1-vertex2
            self.__graphEdges.pop(name) #Remove edge from general dictionary
            self.__graphDict[sa].removeEdge(name) #Removes edge key to vertex1
            self.__graphDict[sb].removeEdge(name) #Removes edge key to vertex2
        elif sa in self.__graphDict:
            raise KeyError('Vertex '+sb+' does not exist')
        elif sb in self.__graphDict:
            raise KeyError('Vertex '+sa+' does not exist')
        else:
            raise KeyError('Vertices '+sa+' and '+sb+' do not exist')



def readStations(graph,file):
    csvfile = open(file)
    reader = csv.DictReader(csvfile)
    for row in reader:
        name = row['station'].lower()
        name = name.replace(" ", "_")
        graph.addVertex(name,row['station'],row['latitude'],row['longitude'])
    return graph

def readConnections(graph,file):
    csvfile = open(file)
    reader = csv.DictReader(csvfile)
    for row in reader:
        sa = row['Station 1'].lower()
        sa = sa.replace(" ", "_")
        sb = row['Station 2'].lower()
        sb = sb.replace(" ", "_")
        value = row['Line']
        weight = row['time']
        graph.addEdge(sa,sb,value,weight)
    return graph

underground=Graph() #Creates empty graph

#Adds stations and connections
underground=readStations(underground,'London_Underground_Stations.csv')
underground=readConnections(underground,'London_Underground_Connections.csv')

#print(underground.isAdjacent('paddington','royal_oak'))

'''
underground.addVertex('baker_street','Baker Street',51.5226,-0.1571)
underground.addVertex('marylebone','Marylebone',51.5225,-0.1631)
print(underground.getVertices())
underground.addEdge('baker_street','marylebone','Bakerloo Line',1)
print(underground.getEdges('marylebone')['baker_street-marylebone'].getVertices())
'''