'''
     _____                 _
    |  ___|   _ _ __   ___(_) ___  _ __   ___  ___
    | |_ | | | | '_ \ / __| |/ _ \| '_ \ / _ \/ __|
    |  _|| |_| | | | | (__| | (_) | | | |  __/\__ \.
    |_|   \__,_|_| |_|\___|_|\___/|_| |_|\___||___/

'''
import sqlite3
import calendario as cal
import admin as adm
import webbrowser
import pandas as pd
import os

from tkinter import *
from t3 import calendario
def exportar_a_fichero(Tabla):
    '''
        Exporta una tabla a fichero
    '''
    database = "agenda.db"
    conn = create_connection(database)
    consulta = pd.read_sql_query(f"SELECT * FROM '{Tabla}'", conn)
    df = pd.DataFrame(consulta)
    path = r"{}\{}.csv".format(os.getcwd(), Tabla)
    df.to_csv (path, index = False)

def abrir_google_maps(url):
    '''
        Abre la url deseada
    '''
    webbrowser.open_new(url)

def create_connection(db_file):
    '''
        Recibe un fichero de base de datos y 
        devuelve una conexion sqlite3
    ''' 
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        return conn
    except sqlite3.Error as e:
        print(e)

    return conn

def create_table(conn, create_table_sql):
    '''
        Recibe una consulta SQL para crear una tabla 
        y la ejecuta sobre la base de datos
    ''' 
    try:
        c = conn.cursor()
        c.execute(create_table_sql)
    except sqlite3.OperationalError as e:
        print(e)

def crear_tabla_usuarios(database):
    '''
        Crea la tabla Usuarios
    '''
    sql_create_citas_table = """ CREATE TABLE IF NOT EXISTS Usuarios ( 
                                        username text PRIMARY KEY,
                                        password text
                                        ) ; """
    
    conn = create_connection(database)
    
    if conn is not None:
        create_table(conn, sql_create_citas_table)
    else:
        print("Error! cannot create citas table")
    return

def crear_tabla_citas(database):
    '''
        Crea la tabla Citas
    '''
    sql_create_citas_table = """ CREATE TABLE IF NOT EXISTS Citas ( 
                                    id_cita integer PRIMARY KEY AUTOINCREMENT,
                                    username integer,
                                    nombre text,
                                    descripcion text,
                                    lugar text,
                                    fecha text,
                                    hora text,
                                    importancia integer,
                                    FOREIGN KEY(username) REFERENCES Usuarios(username)
                                    ) ; """
    
    conn = create_connection(database)
    
    if conn is not None:
        create_table(conn, sql_create_citas_table)
    else:
        print("Error! cannot create citas table")
    return

def crear_tabla_ajustes(database):
    '''
        Crea la tabla Ajustes
    '''
    sql_create_citas_table = """ CREATE TABLE IF NOT EXISTS Ajustes ( 
                                        username text PRIMARY KEY,
                                        font text DEFAULT 'Times',
                                        fontsize integer DEFAULT 14,
                                        background_color text DEFAULT '#0B5A81'
                                        ) ; """
    
    conn = create_connection(database)
    
    if conn is not None:
        create_table(conn, sql_create_citas_table)
    else:
        print("Error! cannot create citas table")
    return

def insert_row_citas(id_user,nombre, descripcion, lugar,fecha,hora, importancia):
    '''
        Inserta una cita en la tabla Citas 
    '''
    try:
        database = "agenda.db"
        conn = create_connection(database)
        c = conn.cursor()
        introducir_cita = f"""INSERT INTO Citas (username,nombre,descripcion,lugar,fecha,hora,importancia) 
                                VALUES ('{id_user}','{nombre}','{descripcion}','{lugar}', '{fecha}','{hora}','{importancia}');"""
        print('Insertando ', introducir_cita)
        c.execute(introducir_cita)
        conn.commit()
        conn.close()
    except sqlite3.OperationalError as msg:
        print("Error en el registro de citas ")
        print(msg)

def get_cita(username,fecha):
    '''
        Obtiene la cita de un usuario en una fecha determinada
    '''
    try:
        database = "agenda.db"
        conn = create_connection(database)
        c = conn.cursor()
        buscar_factura= f"SELECT * from Citas WHERE fecha= '{fecha}' and username = '{username}' ;"
        c.execute(buscar_factura)
        row = c.fetchone()
        if row:  # Una fila devuelta
            print('Cita encontrada - Get Citas OK')
        else:
            print('Cita NO encontrado - Get Citas ERROR')
        return row     
    except sqlite3.OperationalError as msg:
        print("Error al encontrar la de facturas")
        
def drop_table(tabla):
    '''
        Recibe una consulta SQL para borrar una tabla 
        y la ejecuta sobre la base de datos
    '''
    try:
        conn = create_connection('agenda.db')
        c = conn.cursor()
        borrar_tabla = f"DROP TABLE {tabla} ;"
        c.execute(borrar_tabla)
    except sqlite3.OperationalError as msg:
        print(msg)
        print("Error al encontrar la de citas")

def borrar_cita():
    '''
        Borra una cita de la BBDD    
    '''
    try:
        conn = create_connection('agenda.db')
        c = conn.cursor()
        query = f"DELETE from Citas where Fecha"
        c.execute(query)
    except sqlite3.OperationalError as msg:
        print(msg)
        print("Error al encontrar la de citas")

def get_citas_importancia():
    '''
        Devuelve un listado de las citas de un usuario con su importancia
    '''
    database = "agenda.db"
    conn = create_connection(database)
    c = conn.cursor()
    buscar_factura= f"SELECT fecha, importancia from Citas;"
    c.execute(buscar_factura)
    res = c.fetchall()
    return res
        
def drop_table_citas():
    '''
        Recibe una consulta SQL para crear una tabla 
        y la ejecuta sobre la base de datos
    '''
    try:
        conn = create_connection('agenda.db')
        c = conn.cursor()
        borrar_tabla = f"DROP TABLE Citas ;"
        c.execute(borrar_tabla)
    except sqlite3.OperationalError as msg:
        print(msg)

def login_attempt(username,password,padre):
    '''
        Realizamos un intento de login con los 
        datos proporcionados en la BBDD
    '''
    if len(password) != 0:
        print('Login')
        # Comprobar usuario en BBDD
        conn = create_connection('agenda.db')
        buscar_usuario = f"SELECT username from Usuarios WHERE username='{username}' and password='{password}';"
        c = conn.cursor()
        c.execute(buscar_usuario)
        row = c.fetchone()
        if row:  # Una fila devuelta
            print('Usuario encontrado - Login OK')
            print(row)
            padre.destroy()
            # Cambiar por el calendario
            if row[0] == "admin":
                adm.ventana_admin()
            else:
                calendario(username)
            return
        else:
            print('Usuario NO encontrado - Login ERROR')
            print('Usuario o contraseña INCORRECTA')
    else:
        print('Password vacia')

def register_attempt(username,passwd,repasswd,padre):
    '''
        Intentamos hacer un registro en la base de datos
        Si Register_OK --> True
        [] --> False
    '''
    if passwd == repasswd and len(passwd) > 0:
        conn = create_connection('agenda.db')
        buscar_usuario = f"SELECT username from Usuarios WHERE username='{username}';"
        c = conn.cursor()
        c.execute(buscar_usuario)
        row = c.fetchone()
        if not row:  # Ninguna fila devuelta
            registrar_usuario =  f"INSERT INTO Usuarios (username,password) VALUES('{username}','{passwd}');"
            try:
                c.execute(registrar_usuario)

                default_settings =  f"INSERT INTO Ajustes (username) VALUES('{username}');"
                c.execute(default_settings)
                conn.commit()
                conn.close()
                print("Registro usuario OK")
                padre.destroy()
                 
            except sqlite3.OperationalError as msg:
                print("Registro usuario ERROR")
                print(msg)
        else:
            print('El usuario ya existe en la BBDD ')
            print(row)
    else:
        print("Las password no coinciden o son NULL")

def get_user_settings(username):
    '''
        Obtiene los settings del usuario
    '''
    conn = create_connection('agenda.db')
    listar = f"SELECT * from Ajustes WHERE username = '{username}';"
    c = conn.cursor()
    c.execute(listar)
    user_settings = c.fetchone()

    return user_settings

def listado_bbdd():
    '''

    '''
    conn = create_connection('agenda.db')
    listar = f'SELECT username from Usuarios;'
    c = conn.cursor()
    c.execute(listar)
    rows = c.fetchall()
    for row in rows:
        print(row)
        
def listado_citas_usuario(username):
    '''
        Devuelve las citas del usuario @param(username)
    '''
    conn = create_connection('agenda.db')
    listar = f"SELECT fecha, importancia from Citas WHERE username LIKE '{username}';"
    c = conn.cursor()
    c.execute(listar)
    rows = c.fetchall()
    citas_importancia = []
    # result = [dict(row) for row in c.fetchall()]
    for row in rows:
        citas_importancia.append(row)

    return citas_importancia
    
def create_tables_agenda(db_file):
   '''
       Crea las tablas necesarias para ejecutar la agenda
   '''
   crear_tabla_usuarios(db_file)
   print('Tabla Usuarios creada con exito!')

   crear_tabla_citas(db_file)
   print('Tabla Citas creada con exito!')

   crear_tabla_ajustes(db_file)
   print('Tabla Ajustes creada con exito!')
