import networkx as nx
import math
from itertools import tee
import pickle
from numpy import Inf, Infinity, inf
from database.database import DB
import pandas as pd
from haversine import haversine
import time
import pandas as pd
import os

paths= os.getcwd()

def dist(a, b):
    (x1, y1) = a
    (x2, y2) = b
    return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5

def swith_xy(tuples):
    x,y=tuples
    return (y,x)
    
def pairwise( iterable ):
    """Returns an iterable access binary tuple
    s -> (s0,s1), (s1,s2), (s2, s3), ..."""
    a, b = tee( iterable )
    next(b, None)
    return zip(a, b)



class path_finder():
    def __init__(self):
        start_time=time.time()
        self.db=DB()
        with open(paths + '\\navigation_model\\OSM_gpickle.gpickle', 'rb') as f:
            self.G = pickle.load(f)
        #self.G=nx.read_gpickle(paths + '\\navigation_model\\OSM_gpickle.gpickle')
        
        print("done")
        print(time.time()-start_time)


    
    def get_trip(self,dest1,dest2):

        start_time=time.time()
        dest1=swith_xy(self.db.db_get_dest(dest1))
        dest2=swith_xy(self.db.db_get_dest(dest2))
        value=0.0001

        start_near_nodes=[]
        while start_near_nodes == []:
            value=value*10
            start_near_nodes=self.db.db_get_near_node(dest1[1],dest1[0],value)
        else: 
            start_near_nodes=self.db.db_get_near_node(dest1[1],dest1[0],value)

        nn_start = None
        nn_end = None
        start_delta = float("inf")
        end_delta = float("inf")
        


        for n in start_near_nodes:
            s_dist = haversine(dest1, n)
            if s_dist < start_delta :
                    nn_start = n
                    start_delta = s_dist
        value=0.0001
        end_near_nodes=[]
        while end_near_nodes==[]:
            value=value*10
            self.db.db_get_near_node(dest2[1],dest2[0],value)
            end_near_nodes=self.db.db_get_near_node(dest2[1],dest2[0],value)

        for n in end_near_nodes:
            e_dist = haversine(dest2, n)
            if e_dist < end_delta :
                    nn_end = n
                    end_delta = e_dist
            
        path = list(nx.astar_path(self.G,nn_start,nn_end,heuristic=dist,weight='length'))
        return path
    

    def get_trip_2(self,dest1_x,dest1_y,dest2,not_in_list):
        dest1=(float(dest1_x),float(dest1_y))
        
        dest2=swith_xy(self.db.db_get_dest(dest2))
        start_time=time.time()
        value=0.0001

        start_near_nodes=[]
        while start_near_nodes == [] and len(start_near_nodes)<2:
            value=value*10
            start_near_nodes=self.db.db_get_near_node(dest1[1],dest1[0],value)
        else: 
            start_near_nodes=self.db.db_get_near_node(dest1[1],dest1[0],value)

        nn_start = None
        nn_end = None
        start_delta = float("inf")
        end_delta = float("inf")
        


        for n in start_near_nodes:
            s_dist = haversine(dest1, n)
            if s_dist < start_delta :
                if n not in not_in_list:
                    nn_start = n
                    start_delta = s_dist
                else:
                    continue
        value=0.0001
        end_near_nodes=[]
        while end_near_nodes == [] and len(end_near_nodes)<2:
            value=value*10
            self.db.db_get_near_node(dest2[1],dest2[0],value)
            end_near_nodes=self.db.db_get_near_node(dest2[1],dest2[0],value)

        for n in end_near_nodes:
            e_dist = haversine(dest2, n)
            if e_dist < end_delta :
                if n not in not_in_list:
                    nn_end = n
                    end_delta = e_dist
                else:
                    continue
            
        path = list(nx.astar_path(self.G,nn_start,nn_end,heuristic=dist,weight='length'))
        return path
    
    def get_dest(self, dest1):
        dest1=swith_xy(self.db.db_get_address(dest1))
        return dest1

# print("출력!!!!!!!!!!!!")
# # path_finder 클래스의 인스턴스를 생성
# path_finder_instance = path_finder()
# not_in_list=[]
# # get_trip_2() 메서드를 호출할 때 인스턴스를 통해 호출
# result = path_finder_instance.get_trip_2(35.8260157, 128.7560105, '경상북도 영덕군 남정면 산정로 159-54', not_in_list)

# print(result)