#!/usr/bin/env python
# coding: utf-8

# In[2]:


import numpy as np
import json
import random


# In[3]:


import vectors as space
#import String as space


# # Funciones Necesarias

# In[4]:


def ordenar(l1):
  l1.sort(key=lambda elem: elem[1])
  aux=list()
  for i in l1:
    aux.append(i[0])
  return aux
  
def perminv(l1):
  aux=list()
  #print(l1)
  for i in range(len(l1)):
    res=l1.index(i+1)
    aux.append(res+1)
  return aux

def maximo(a,b):
  if(a<=b):
    return b
  else:
    return a
    
def posicion(l,x1):
  l1=[x[0] for x in l]
  if(x1 in l1):
    id=l1.index(x1)
  else:
    id=-2
  return id

def SearchP(candidatos,r):
    res=list()
    last=0
    pos=list()
    for c in candidatos:
        distqu=space.Distance(0,c)
        if(distqu<=r):
            res.append(c)
            pos.append((candidatos.index(c),distqu))
    last=candidatos.index(res[-1])        
    return res,pos,last

def SearchPK(candidatos,k):
#Busqueda---------------------------
  r=999999999
  nn=list()
  nnaux=list()
  last=0
  for x in candidatos:
    if(len(nn)==k):
      r=max(nnaux)
      if(space.Distance(0,x)<r):
        last=candidatos.index(x)
        #print(x,"pos:",candidatos.index(x))
        nn[-1]=x
        nnaux[-1]=space.Distance(0,x)
        aux1=list()
        nnaux1=nnaux.copy()
        nnaux1.sort()
        for i in nnaux1:
          aux1.append(nn[nnaux.index(i)])
        nn=aux1
        nnaux=nnaux1

    else:
      aux1=list()
      nn.append(x)
      nnaux.append(space.Distance(0,x))
      nnaux1=nnaux.copy()
      nnaux1.sort()
      for i in nnaux1:
        aux1.append(nn[nnaux.index(i)])
      nn=aux1
      nnaux=nnaux1
  #print(nn)
  #for i in range(k):
    #space.printObj(nn[i],nnaux[i])
  return nn,last


# # funciones de Construcción

# #### Short Perm

# In[5]:


def perm_short(l1):
  #print(l1)
  l1.sort(key=lambda elem: elem[1])
  aux=list()
  contador=0
  region=2*l1[0][1]
  d=l1[0][1]
  
  for i in l1:
    j=i[0]
    aux.append(j)

  for i in range(len(l1)):
    if(l1[i][1]<=region):
      contador=contador+1

  if (contador<=PermlenMin):
    #aux.append(PermlenMin)
    #return aux,d
    return aux[:PermlenMin],d
  elif(contador>=PermlenMax):
    #aux.append(PermlenMax)
    #return aux,d
    return aux[:PermlenMax],d
  else:
    #aux.append(contador)
    #return aux,d
    return aux[:contador],d


# In[6]:


def short_perm(nper):
  ##Seleccionar permutantes
  """
  per=list()
  
  
  while(len(per)<nper):
    P=random.randint(1,(space.tam()-500))
    if(P not in per):
      per.append(P)
  """
  per=per1[:nper]
  #per=[25051, 37640, 33428, 4832, 5995, 39641, 8027, 18977, 18767, 28959, 34532, 19063, 37850, 15924, 13841, 31035]
  #per=[3468, 1291, 5520, 15510, 37128, 38463, 37681, 20476, 3937, 20389, 39165, 30428, 22616, 37605, 39327, 35010, 38264, 6588, 39567, 38787, 34236, 30110, 2197, 6733, 12997, 22477, 1406, 22056, 33347, 29212, 38701, 34332, 26723, 12929, 3330, 28775, 5337, 28094, 9556, 15037, 30073, 34867, 31739, 38317, 16542, 2684, 2886, 38604, 20331, 19319, 5835, 27811, 32497, 21077, 31280, 2554, 27883, 34161, 36198, 39018, 14952, 15341, 20251, 13953]  
  ##matriz de permutaciones
  Pi=[[]]
  piv=[[]]
  auxs=list()
  for i in range(1,(space.tam())):
    aux=[]
    for j in per:
      aux.append((per.index(j)+1,space.Distance(i,j)))  
    p,r=perm_short(aux)
    Pi.append(p)
    piv.append(r)
    auxs.append(aux)

  #promedio de "cortes"
  prom=0
  for i in range(1,len(Pi)):
    prom=prom+len(Pi[i])
  prom=int((prom/(len(Pi)-1)))
  print("Promedio de cortes en permutaciones: ", prom)
  #print(Pi[1])
  #print(aux)
  #creacion de indice
  indice={"db":dbloc,"perm":per,"tablaPerm":Pi,"PromCorte":prom,"piv":piv,"aux":auxs}

  return indice


# #### Perm

# In[7]:


def permutancion(l1):
  #print(l1)
  l1.sort(key=lambda elem: elem[1])
  aux=list()
  contador=0
  #region=2*l1[0][1]
  d=l1[0][0]
  for i in l1:
    j=i[0]
    aux.append(j)
  return aux,d


# In[8]:


def perm(nper):
  ##Seleccionar permutantes
  """
  per=list()

  while(len(per)<nper):
    P=random.randint(1,(space.tam()-500))
    if(P not in per):
      per.append(P)

"""
  per=per1[:nper]
  #per=[25051, 37640, 33428, 4832, 5995, 39641, 8027, 18977, 18767, 28959, 34532, 19063, 37850, 15924, 13841, 31035]
  #per=[3468, 1291, 5520, 15510, 37128, 38463, 37681, 20476, 3937, 20389, 39165, 30428, 22616, 37605, 39327, 35010, 38264, 6588, 39567, 38787, 34236, 30110, 2197, 6733, 12997, 22477, 1406, 22056, 33347, 29212, 38701, 34332, 26723, 12929, 3330, 28775, 5337, 28094, 9556, 15037, 30073, 34867, 31739, 38317, 16542, 2684, 2886, 38604, 20331, 19319, 5835, 27811, 32497, 21077, 31280, 2554, 27883, 34161, 36198, 39018, 14952, 15341, 20251, 13953]  
  ##matriz de permutaciones
  Pi=[[]]
  piv=[[]]
  auxs=list()
  for i in range(1,(space.tam())):
    aux=[]
    for j in per:
      aux.append((per.index(j)+1,space.Distance(i,j)))  
    p,r=permutancion(aux)
    Pi.append(p)
    piv.append(r)
    auxs.append(aux)

  #promedio de "cortes"
  #print(per)
  #print(Pi[1])
  #print(aux)
  #creacion de indice
  indice={"db":dbloc,"perm":per,"tablaPerm":Pi,"piv":piv,"aux":auxs}

  return indice


# ###MIFI

# In[9]:


def mifi(nro,k_i,k_s):
  """
    SELECCION DE LOS ONJETOS DE REFERENCIA
  """
  """
  RO=list()
  while(len(RO)<nro):
    P=random.randint(1,(space.tam()-500))
    #P=random.randint(1,30)
    if(P not in RO):
      RO.append(P)

  """
  RO=per1[:nro]
    
  """
    TRANSFORMACIÓN DE LOS OBJETOS CON TAMAÑO K_I 
  """
  obj_trans=[0]
  for i in range(1,(space.tam())):
  #for i in range(1,30):
    aux=[]
    for ro in RO:
      aux.append((RO.index(ro)+1,space.Distance(i,ro)))
    obj_trans.append(ordenar(aux)[:k_i])

  """
    CREACION DEL INDICE INVERTIDO CON LOS OBJETOS TRANSFORMADOS
      -INDEXACION DE OBJETOS
  """

  inverted_file=[[]]
  for i in range(1,len(RO)+1):
    #pl_i=list()
    pl_i=[-1]*(len(obj_trans)-1)
    for j in range(1,len(obj_trans)):
      if(i in obj_trans[j]):
        pl_i[j-1]=obj_trans[j].index(i)+1
        #pl_i.append((j,obj_trans[j].index(i)+1))
        
    inverted_file.append(pl_i)
  
  """
  CREACION DE DICCIONARIO CON INFORMACIÓN NECESARIA PARA LA CONSULTA
  """
  indice={"db":dbloc,"RO":RO,"mifi":inverted_file,"ks":k_s,"ki":k_i}

  return indice
      


# ### MIFI PM

# In[10]:


def mifi_pm(nro,k_i,k_s):
  """
    SELECCION DE LOS OBJETOS DE REFERENCIA
  """
  """
  RO=list()
  while(len(RO)<nro):
    P=random.randint(1,(space.tam()-500))
    #P=random.randint(1,30)
    if(P not in RO):
      RO.append(P)
  """
  RO=per1[:nro]
  """
    TRANSFORMACIÓN DE LOS OBJETOS CON TAMAÑO K_I 
  """

  obj_trans=[0]
  for i in range(1,(space.tam())):
  #for i in range(1,30):
    aux=[]
    for ro in RO:
      aux.append((RO.index(ro)+1,space.Distance(i,ro)))
    obj_trans.append(ordenar(aux)[:k_i]) #permutacion de tamaño m_i

  """
    CREACION DEL INDICE INVERTIDO CON LOS OBJETOS TRANSFORMADOS
      -INDEXACION DE OBJETOS
  """
  inverted_file=[[]]
  
  for i in range(1,len(RO)+1):
    #pl_i=list()
    pl_i=list()
    for j in range(1,len(obj_trans)):
      if(i in obj_trans[j]):
        pl_i.append(j) #almacena solo el indice del elemento 
        #pl_i.append((j,obj_trans[j].index(i)+1))
        
    inverted_file.append(pl_i)
  
  """
  CREACION DE DICCIONARIO CON INFORMACIÓN NECESARIA PARA LA CONSULTA
  """

  indice={"db":dbloc,"RO":RO,"mifi":inverted_file,"per":obj_trans,"ks":k_s,"ki":k_i}

  return indice


# # Funciones de Consulta

# ### Short Perm

# In[11]:


def query_sp(l1,r):
  #print(l1)
  l1.sort(key=lambda elem: elem[1])
  aux=list()
  contador=0
  region=2*l1[0][1]
  #d=l1[0][0]
  
  for i in l1:
    j=i[0]+1
    aux.append(j)

  for i in range(len(l1)):
    if(l1[i][1]<=region):
      contador=contador+1

  if (contador<=PermlenMin):
    #aux.append(PermlenMin)
    #return aux,d
    return aux,PermlenMin
  elif(contador>=PermlenMax):
    #aux.append(PermlenMax)
    #return aux,d
    return aux,PermlenMax
  else:
    #aux.append(contador)
    #return aux,d
    return aux,contador


# In[12]:


def Distancia_sp(index_sp,i,qinv,m_q):
  Sum=0
  pen=list()
  contpen=0
  contcom=m_q
  maxi=0
  #for j in range(len(Indice["tablaPerm"][i])):       <---- las permutaciones tienen ya el tamaño m_u
  for j in range(len(index_sp["tablaPerm"][i])):        #<--- la ultima posicion tiene en corte m_u
    r1=abs((j+1)-qinv[index_sp["tablaPerm"][i][j]-1])  #<--- calcula desplazamientos
    Sum=Sum+r1                                       #<--- Sum es el total 
    maxi=maximo(maxi,r1)                             #<--- maxi toma el maximo entre desplazamientos
    if(qinv[index_sp["tablaPerm"][i][j]-1]<=m_q):       #<--- Verifica si está el permutante dentro del prefijo de q
      contcom=contcom-1                              #<---decrementa el valor si lo encuentra
    """
    if(Indice["tablaPerm"][i][j] in Indice["tablaPerm"][0][:len(Indice["tablaPerm"][i])]):
      contcom=contcom+1
    #-----------
    if(Indice["tablaPerm"][i][j] in resto):
      contpen=contpen+1
  
  t1=Sum*contcom
  t2=(maxi-1)*(Indice["tablaPerm"][i][-1]-m_q)
  print("----------------",i)
  print("no compartidos",contcom)
  print("dezplacamiento maximo",maxi-1)
  print("tamaño prefijo u",Indice["tablaPerm"][i][-1])
  print("tamaño prefijo q",m_q)
  print("desplazamiento",Sum)
  print("-------F*---------")
  print("Sum*contcom ",t1)
  print("maxi*(mu-mq)",t2)
  """
  #print("desplazamientos: ",Sum , "pen1: ",(Sum*contcom),"pen2: ",((maxi-1)*(len(Indice["tablaPerm"][0])-len(Indice["tablaPerm"][i]))))
  #Sum=Sum+ (Sum*contcom) + ((maxi-1)*(index_sp["tablaPerm"][i][-1]-m_q))
  Sum=Sum+ (Sum*contcom) + ((maxi)*(len(index_sp["tablaPerm"][0])-len(index_sp["tablaPerm"][i])))
  #Sum=Sum+ (Sum*contcom) + ((maxi-1)*(len(Indice["tablaPerm"][0])-Indice["tablaPerm"][i][-1]))
  #print("total ",Sum)
  return Sum


# In[13]:


def Search_sp(index_sp,q,r):
  space.add(q)
  #permutacion q
  qperm=[]
  qdis=list()
  for x in index_sp["perm"]:
    dq=space.Distance(0,x)
    qperm.append((index_sp["perm"].index(x),dq))
    qdis.append(dq)
  index_sp["tablaPerm"][0],mq=query_sp(qperm,r)
  
  qinv=perminv(index_sp["tablaPerm"][0])
  qdis.sort()

  if(r<0):
    r1=qdis[abs(r)]
  else:
    r1=r


  #print(qdis[0])
  #print(mq)
  #print(qinv)
  #print(qdis)
#-------------------------
  aux=[]
  #calculo de las distancias----------------------------------------------------
  for i in range(1,len(index_sp["tablaPerm"])):
    if(abs(index_sp["piv"][i]-qdis[index_sp["tablaPerm"][0].index(index_sp["tablaPerm"][i][0])])<abs(r1)):
      aux.append((i,Distancia_sp(index_sp,i,qinv,mq)))
  candidatos=ordenar(aux)

  #print(candidatos[97])
  #print(Indice["tablaPerm"][39650])
  #print("último",candidatos.index(39650))
  #for i in range(10): print(candidatos[i])
##Busqueda----------------------------------------------------------------------
  ans=list()
  if(r>0):
    ans=SearchP(candidatos,r)
    #pass
  else:
    ans=SearchPK(candidatos,-r)
  space.pop()
  return ans


# ### Perm

# In[14]:


def query_p(l1,r):
  #print(l1)
  l1.sort(key=lambda elem: elem[1])
  aux=list()
  for i in l1:
    j=i[0]+1
    aux.append(j)
  return aux


# In[15]:


def Distancia_p(index_p,i,qinv):
  Sum=0
  #p_inv=perminv(Indice["tablaPerm"][i][:len(Indice["tablaPerm"][i])-1])
  for j in range(len(index_p["tablaPerm"][i])):
    r1=abs((j+1)-qinv[index_p["tablaPerm"][i][j]-1])  #<--- calcula desplazamientos
    Sum=Sum+r1                                       #<--- Sum es el total 
  return Sum


# In[39]:


def Search_p(index_p,q,r):
  space.add(q)
  #permutacion q
  qperm=[]
  for x in index_p["perm"]:
    qperm.append((index_p["perm"].index(x),space.Distance(0,x)))

  index_p["tablaPerm"][0]=query_p(qperm,r)
  
  qinv=perminv(index_p["tablaPerm"][0])
  #print(qinv)
  #print(qdis[0])
  #print(qdis)

#-------------------------
  aux1=[]
  #calculo de las distancias----------------------------------------------------
  for i in range(1,len(index_p["tablaPerm"])):
    aux1.append((i,Distancia_p(index_p,i,qinv)))

  candidatos1=ordenar(aux1)
  #print(candidatos[97])
  #print(Indice["tablaPerm"][39650])
  #print("último",candidatos.index(39650))
  #for i in range(10): print(candidatos[i])
##Busqueda----------------------------------------------------------------------
  ans=list()
  if(r>0):
    ans=SearchP(candidatos1,r)
    #pass
  else:
    ans1=SearchPK(candidatos1,-r)
  space.pop()
  return ans


# ### MIFI

# In[17]:


def posicion(l,x1):
  l1=[x[0] for x in l]
  if(x1 in l1):
    id=l1.index(x1)
  else:
    id=-2
  return id


# In[18]:


def Search_mifi(index_m,q,r):
  """
    TRANSFORMACION DE LA CONSULTA CON TAMAÑO ks
  """
  space.add(q)
  q_dist=list()
  for ro in index_m["RO"]:
    q_dist.append((index_m["RO"].index(ro)+1,space.Distance(0,ro)))

  index_m["mifi"][0]=ordenar(q_dist)[:index_m["ks"]]
  
  """
    SELECCIÓN DE CANDIDATOS DENTRO DEL INDICE INVERTIDO
  """
  """
  A=list()
  for ro in index_m["mifi"][0]:
    pl=index_m["mifi"][ro]
    for obj_dis in pl:
      if(len(A)==0 or (obj_dis[0] not in [x[0] for x in A])):
        a_0=(obj_dis[0],(index_m["ki"]+1)*index_m["ks"])
        A.append(a_0)
      i=posicion(A,obj_dis[0])
      a_0=A[i][1]-(index_m["ki"]+1)+abs((index_m["mifi"][0].index(ro)+1)-obj_dis[1])
      A[i]=(obj_dis[0],a_0)
  """
  A=[0]*(len(index_m["mifi"][1]))
  for ro in index_m["mifi"][0]:
    pl=index_m["mifi"][ro]
    for i in range(len(pl)):
      if(pl[i] !=-1):
        if(A[i]==0):
          A[i]=(index_m["ki"]+1)*index_m["ks"]
        A[i]=A[i]-(index_m["ki"]+1)+abs((index_m["mifi"][0].index(ro)+1)-pl[i])

  
  candidatos=ordenar(list(enumerate(A,1)))
  #print(candidatos)
  ans=list()
  if(r>0):
    ans=SearchP(candidatos,r)
    #pass
  else:
    ans=SearchPK(candidatos,-r)
  space.pop()
  return ans




# ### MIFI pm

# In[19]:


def query_trans(l1,alpha,r,ms):
  l1.sort(key=lambda elem: elem[1])
  msr=1
  if(r>0):
    d_u=l1[0][1]+ (alpha*r)
  else:
    d_u=l1[0][1]+ (alpha*l1[abs(r)-1][1])

  for i in range(ms):
    if(l1[i][1]<=d_u):
      msr=msr+1

 
  return ordenar(l1),msr

def union_pl(index,msr):
  pre_c=set()
  for x in index["per"][0][:msr]:
    pre_c=pre_c.union(set(index["mifi"][x]))
  return list(pre_c)
  



# In[20]:


def Search_mifi_pm(index_m,q,r,alpha):
  """
    TRANSFORMACION DE LA CONSULTA CON TAMAÑO VARIABLE SEGUN alpha ,d*_u_1 Y ks
  """

  space.add(q)
  q_dist=list()
  for ro in index_m["RO"]:
    q_dist.append((index_m["RO"].index(ro)+1,space.Distance(0,ro)))

  index_m["per"][0],msr=query_trans(q_dist,alpha,r,index_m["ks"])
  #print(index_m["mifi"][0])

  pre_candidatos=union_pl(index_m,msr)


  """
    SELECCIÓN DE CANDIDATOS DENTRO DEL INDICE INVERTIDO
  """
  """
  A=[0]*(len(index_m["mifi"][1]))
  for ro in index_m["per"][0]:
    pl=index_m["mifi"][ro]
    for i in range(len(pl)):
      if(pl[i] !=-1):
        if(A[i]==0):
          A[i]=(index_m["ki"]+1)*index_m["ks"]
        A[i]=A[i]-(index_m["ki"]+1)+abs((index_m["mifi"][0].index(ro)+1)-pl[i])
  """
  aux=list()
  for u in pre_candidatos:
    s=0
    p_u=index_m["per"][u]
    for i in range(len(p_u)):
      s=s+abs((i+1)-(index_m["per"][0].index(p_u[i])+1))
    aux.append((u,s))

  candidatos=ordenar(aux)
  #candidatos=ordenar(list(enumerate(A,1)))
  #print(candidatos)
  ans=list()
  if(r>0):
    ans=SearchP(candidatos,r)
    #pass
  else:
    ans=SearchPK(candidatos,-r)
  space.pop()
  return ans


# # queries

# ### Construcción de Indices

# In[21]:


#dbloc="/content/drive/MyDrive/test.txt"
#dbloc="/content/drive/MyDrive/nasa.ascii"
#dbloc="/content/drive/MyDrive/English.dic"
dbloc='/home/karina/metricSpaces/dbs/sift/sift_base.ascii'

print("cargando base de datos")
with open(dbloc) as f:
  x=f.readlines()
db_list=list()
for i in range(1,len(x)-1):
  db_list.append([float(s) for s in x[i].replace(","," ").split()])


space.loadDB(db_list)

PermlenMin=8
PermlenMax=32
print("base de datos cargada")
#per1=[30077, 30394, 1218, 3215, 26084, 16738, 20088, 20774, 32579, 3224, 20051, 37931, 36192, 30132, 30997, 30882, 4134, 24229, 16501, 5223, 3777, 13497, 13436, 31054, 31335, 1176, 11664, 35845, 6918, 27955, 31339, 28108, 24626, 36947, 37648, 19782, 9915, 9835, 8443, 16601, 31424, 29342, 22900, 29319, 24743, 24298, 9354, 12645, 17739, 32365, 19668, 14921, 38331, 16037, 3316, 1306, 26424, 24022, 25015, 3151, 26957, 758, 20059, 33491, 13918, 513, 23410, 2052, 36823, 27288, 11229, 36934, 28801, 4300, 18796, 37431, 9022, 25237, 36075, 13777, 35076, 26364, 28743, 36156, 32553, 39141, 30255, 37999, 36693, 1490, 16927, 18359, 34235, 33347, 3920, 20731, 13050, 30301, 21588, 28332, 8881, 31221, 6996, 1865, 2699, 19291, 20971, 26379, 12381, 14489, 17486, 28452, 18953, 879, 19303, 100, 6990, 8529, 28999, 14186, 36077, 630, 847, 6556, 7626, 17042, 24978, 5152]
per1=[112366, 700725, 491928, 218392, 452763, 685632, 985208, 205427, 999687, 254723, 207012, 450164, 955863, 457662, 608071, 327071, 880742, 818737, 900604, 864196, 692924, 149473, 862421, 447228, 910958, 809593, 398005, 632875, 92917, 958689, 406725, 214744, 907758, 945938, 360435, 2555, 674829, 611346, 443574, 955726, 141965, 668422, 808576, 645810, 766310, 609740, 773289, 245192, 452507, 160057, 892396, 862049, 525558, 419655, 373435, 507923, 802527, 190900, 520990, 432745, 452606, 957958, 284251, 351902, 191018, 26539, 213950, 742752, 554265, 154727, 978961, 72958, 178277, 520526, 861929, 883088, 872412, 260155, 119991, 977520, 667001, 183482, 19971, 605876, 334162, 913424, 622809, 176376, 970737, 933306, 643583, 250296, 914122, 210875, 773786, 545939, 449756, 556000, 152312, 629940, 609169, 794992, 264148, 184824, 678285, 613872, 794365, 545961, 852458, 675138, 132895, 218615, 186023, 270287, 79615, 952074, 743943, 622274, 48123, 239738, 112582, 894422, 825554, 552806, 954412, 257993, 175280, 858649]


# In[22]:


"""
per1=list()
while(len(per1)<128):
  P=random.randint(1,(space.tam()-500))
  if(P not in per1):
    per1.append(P)
per1
"""


# In[23]:

"""
index_p_64=perm(64)
index_p_32=perm(32)


# In[24]:


index_sp_64=short_perm(64)
index_sp_128=short_perm(128)


# In[25]:


index_mifi_1=mifi(64,32,16)
index_mifi_pm=mifi_pm(64,32,16)
"""

# In[26]:

print("cargando indices")
#index_sp_64=short_perm(64)
#index_sp_128=short_perm(128)

index_sp_128=list()
with open('./test_sp_128.json') as f:
    index_sp_128 = json.load(f)
print("sp_128 listo")

#index_p_64=list()
#with open('./test__64.json') as f:
#    index_p_64 = json.load(f)
#print("p_64 listo")
#index_p_32=list()
#with open('./test__p32.json') as f:
#    index_p_32 = json.load(f)
#index_p_32=perm(32)
#print("p_32 listo")
index_sp_64=list()
with open('./test_sp_64.json') as f:
    index_sp_64 = json.load(f)
print("sp_64 listo")

"""
index_mifi_1=list()
with open('./test_mifi_1.json') as f:
    index_mifi_1 = json.load(f)
print("mifi listo")
index_mifi_pm=list()
with open('./test_mifi_pm.json') as f:
    index_mifi_pm = json.load(f)
print("mifi_pm listo")
"""
print("indices cargados")


# ### Carga de Querys

# In[29]:

print("cargando consultas")
x1=list()
with open('/home/karina/metricSpaces/dbs/sift/sift_query.ascii.r10.q') as f:
  x1=f.readlines()

prequerys=list()
querys=list()
radios=list()
for i in range(len(x1)-1):
    prequerys.append([float(s) for s in x1[i].replace(","," ").split()])
    radios.append(prequerys[i][0])
    querys.append(prequerys[i][1:])
print("consultas cargadas")

# In[33]:


#Search_sp(index_sp_128,querys[0],radios[0])


# In[34]:


[140265, 482791, 288398, 744810, 744810, 483146, 547032, 83954]


# In[35]:


#len(index_mifi_1["mifi"])


# In[40]:

"""
index_sp_128["tablaPerm"][0]=[]
index_sp_64["tablaPerm"][0]=[]
index_p_64["tablaPerm"][0]=[]
#index_p_32["tablaPerm"][0]=[]
index_mifi_1["mifi"][0]=[]
index_mifi_pm["mifi"][0]=[]
"""

# In[41]:

"""
print(len(index_sp_128["tablaPerm"][0]))
print(index_sp_128["tablaPerm"][0])
print(index_sp_64["tablaPerm"][0])
print(index_p_64["tablaPerm"][0])
print(index_mifi_1["mifi"][0])
print(index_mifi_pm["mifi"][0])
"""

# ### Busquedas

# In[ ]:

print("----------HACIENDO CONSULTAS-----------")
sp_64=list()
sp_128=list()
sp_64_1=list()
sp_128_1=list()
#p_64=list()
#p_32=list()
#mifi_1=list()
#mifi_pm=list()
cont=0
x=[[],[],[],[],[]]
for i in range(len(querys)):
    cont=cont+1
    sp_res_1=list()
    sp_res_2=list()
    #p_res_1=list()
    sp_res_1=Search_sp(index_sp_64,querys[i],radios[i])
    sp_res_2=Search_sp(index_sp_128,querys[i],radios[i])
    #p_res_1=Search_p(index_p_32,querys[i],radios[i])
    #print("64: ",sp_res_1[:2])
    x[0].append(sp_res_1[:2])
    x[1].append(sp_res_2[:2])
    x[2].append(sp_res_1[2:])
    x[3].append(sp_res_2[2:])
    #x[2].append(Search_p(index_p_64,querys[i],radios[i]))
    #x[3].append(Search_mifi(index_mifi_1,querys[i],radios[i]))
    #x[4].append(Search_mifi_pm(index_mifi_pm,querys[i],radios[i],0))
    #x[5].append(Search_p(index_p_32,querys[i],radios[i])[1])
    print("consulta: ",cont)

#p_32.append(x[0])
sp_64.append(x[0])
sp_128.append(x[1])
print(np.mean(x[2]))
print(np.mean(x[3]))
sp_64_1.append(np.mean(x[2]))
sp_128_1.append(np.mean(x[3]))

#print(p_32_1)
#print(sp_128_1)

cons_res_test={"sp64":sp_64
               
              }
cons_res_test_1={
               "sp64":p_64_1,
               "sp128":p_128_1
              }
with open('./resul_prueba_grande_sp64_.json', 'w') as f:
    json.dump(cons_res_test_1, f,indent=4)

#p_64.append(x[2])
#mifi_1.append([3])
#mifi_pm.append(x[4])
#p_32.append((1,np.mean(x[5])))


# In[ ]:


"""
sp_64=list()
sp_128=list()
p_64=list()
p_32=list()
mifi_1=list()
mifi_pm=list()
for i in range(1,10):
    cont=0
    x=[[],[],[],[],[],[]]
    for q_i in querys:
        cont=cont+1
        x[0].append(Search_sp(index_sp_64,q_i,-i)[1])
        x[1].append(Search_sp(index_sp_128,q_i,-i)[1])
        x[2].append(Search_p(index_p_64,q_i,-i)[1])
        x[3].append(Search_mifi(index_mifi_1,q_i,-i)[1])
        x[4].append(Search_mifi_pm(index_mifi_pm,q_i,-i,0)[1])
        x[5].append(Search_p(index_p_32,q_i,-i)[1])
        print("consulta: ",cont)
    sp_64.append((i,np.mean(x[0])))
    sp_128.append((i,np.mean(x[1])))
    p_64.append((i,np.mean(x[2])))
    mifi_1.append((i,np.mean(x[3])))
    mifi_pm.append((i,np.mean(x[4])))
    p_32.append((i,np.mean(x[5])))
    print("knn= ",i)
"""


# In[ ]:


#print(np.mean(x[0]))


# In[ ]:

"""
print(sp_64)
print(sp_128)
print(p_64)
print(mifi_1)
print(mifi_pm)
"""

# In[ ]:

"""
l1=list()
l2=list()
l3=list()
l4=list()
l5=list()
#l6=list()
for i in range(len(sp_64)):
    l1.append(sp_64[i][1])
    l2.append(sp_128[i][1])
    l3.append(p_64[i][1])
    l4.append(mifi_1[i][1])
    l5.append(mifi_pm[i][1])
    #l6.append(p_32[i][1])


# # Muestra de Resultados

# In[ ]:


import matplotlib.pyplot as plt

plt.plot(l1, label = "short 64")
plt.plot(l2, label = "short 128")
plt.plot(l3, label = "perm 64")
plt.plot(l4, label = "mifi perm=64 mi=32 ms=16")
plt.plot(l5, label ="mifi_pm perm=64 mi=32 ms=16")
plt.legend()


# In[ ]:


#plt.plot(l4, label ="mifi")
plt.plot(l1, label = "short 64")
plt.plot(l2, label = "short 128")
plt.plot(l3, label = "perm 64")
plt.plot(l4, label = "mifi perm=64 mi=32 ms=16")
plt.plot(l5, label ="mifi_pm perm=64 mi=32 ms=16")
#plt.plot(l6, label ="p32")
plt.savefig('./grafica_resultados_grandes.png')
plt.legend()

"""
# # Guardar Resultados


# In[ ]:
"""
#"p32":l6
cons_res_test={"sp64":l1,
               "sp128":l2,
               "p64":l3,
               "mifi":l4,
               "mifipm":l5
              }

cons_res_test={"sp64":sp_64,
               "sp128":sp_128,
               "p64":p_64,
               "mifi":mifi_1,
               "mifipm":mifi_pm
              }
"""

# In[ ]:


with open('./resul_prueba_grande_64.json', 'w') as f:
    json.dump(cons_res_test, f,indent=4)
    


# In[ ]:


#with open('./test_sp_64.json', 'w') as f:
 #   json.dump(index_sp_64, f,indent=4)
    


# In[ ]:


#with open('./test_sp_128.json', 'w') as f:
 #   json.dump(index_sp_128, f,indent=4)


# In[ ]:


#with open('./test__64.json', 'w') as f:
 #   json.dump(index_p_64, f,indent=4)


# In[ ]:


#with open('./test_mifi_1.json', 'w') as f:
 #   json.dump(index_mifi_1, f,indent=4)
  


# In[ ]:


#with open('./test_mifi_pm.json', 'w') as f:
 #   json.dump(index_mifi_pm, f,indent=4)
  


# In[ ]:


#with open('./test__p32.json', 'w') as f:
 #   json.dump(index_p_32, f,indent=4)
  


# In[ ]:


c=[1,2,3,4]
print(c[:1])