#define _POSIX_C_SOURCE 200809L //getline
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "strutil.h"
#include "pila.h"
#include "lista.h"

//Definicion de los tipos de dato
typedef struct pago {
    size_t id;
    char* codigo;
    double monto;
} pago_t;

typedef struct usuario {
    size_t id;
    char* coordenadas;
    double saldo;
} usuario_t;

//Funciones auxiliares

int contar_lineas(char* nombre_archivo){

    //Utilidad de getline
    char* linea = NULL;
    size_t capacidad = 0;
    ssize_t leidos;

    FILE* f_cuentas_usuarios = fopen(nombre_archivo,"r"); //Validar que se pudo abrir!!!
    int numero_lineas = 0;
    while((leidos = getline(&linea,&capacidad,f_cuentas_usuarios)) > 0){
        numero_lineas++;
    }
    free(linea);
    fclose(f_cuentas_usuarios);
    return numero_lineas;
}

int contar_parametros_leidos(char** leidos_stdin){
    int i = 0;
    while(leidos_stdin[i] != NULL){
        i++;
    }
    return i;
}

void borrar_salto_de_linea(char* str){
    size_t largo_str = strlen(str);
    str[largo_str] = '\0';
}

//Funciones con usuarios & pagos

usuario_t* cargar_usuario(char* id_usuario, char* saldo, char* coordenadas){
    usuario_t* usuario = malloc(sizeof(usuario_t));

    usuario->id = (size_t)atoi(id_usuario);
    usuario->saldo = (double)atof(saldo);

    borrar_salto_de_linea(coordenadas);
    usuario->coordenadas = coordenadas;
    return usuario;
}

usuario_t** cargar_usuarios_a_vector(char* nombre_archivo, size_t* cantidad_usuarios){
    int numero_lineas_archivo = contar_lineas(nombre_archivo);

    usuario_t** vector_usuarios = malloc(sizeof(usuario_t) * (numero_lineas_archivo + 1));
    if(!vector_usuarios){
        return NULL;
    }

    FILE* f_cuentas_usuarios = fopen(nombre_archivo,"r"); //Validar que se pueda abrir

    //Utilidad de getline
    char* linea = NULL;
    size_t capacidad = 0;

    size_t i = 0;
    for(i = 0; i < numero_lineas_archivo; i++){
        getline(&linea,&capacidad,f_cuentas_usuarios);
        char** linea_parseada = split(linea, ',');

        vector_usuarios[i] = cargar_usuario(linea_parseada[0], linea_parseada[1], linea_parseada[2]);
    }
    *cantidad_usuarios = numero_lineas_archivo;

    //Pongo el ultimo como NULL para poder iterar sobre el array
    vector_usuarios[numero_lineas_archivo] = NULL;
    return vector_usuarios;
}

usuario_t* buscar_usuario(size_t id_usuario, usuario_t** vector_usuarios, size_t cantidad_usuarios){
    if(id_usuario >= cantidad_usuarios){
        return NULL;
    }
    usuario_t* usuario_buscado = vector_usuarios[id_usuario];
    return usuario_buscado;
}

pago_t* cargar_pago(char* id_pago, char* monto, char* codigo){
    pago_t* pago = malloc(sizeof(pago_t));

    pago->id = (size_t)atoi(id_pago);
    pago->monto = (double)atof(monto);

    borrar_salto_de_linea(codigo);
    pago->codigo = codigo;
    return pago;
}

//Funciones de codigo de pila

bool validar_usuario(pila_t* pila_codigo, usuario_t** vector_usuarios, size_t cantidad_usuarios){
    char* coordenadas = pila_desapilar(pila_codigo);
    size_t id = (size_t)atoi(pila_desapilar(pila_codigo));

    //buscar_usuario devuelve NULL si no lo encuentra
    usuario_t* usuario = buscar_usuario(id, vector_usuarios, cantidad_usuarios);

    //Controla que el ID exista
    if(!usuario){
        return false;
    } else {
        //Controla que el ID coincida con las coordenadas
        if(strcmp(usuario->coordenadas,coordenadas) != 0){
            return true;
        } else
            return false;
    }
}

bool validar_pago(pila_t* pila_codigo, usuario_t** vector_usuarios, size_t cantidad_usuarios){
    double monto = atof(pila_desapilar(pila_codigo));;
    size_t id_usuario = (size_t)atoi(pila_desapilar(pila_codigo));

    usuario_t* usuario = buscar_usuario(id_usuario, vector_usuarios, cantidad_usuarios);

    //Valida que el usuario tenga saldo suficiente para el pago
    if(usuario->saldo >= monto){
        return true;
    }
    return false;
}

bool pagar(pila_t* pila_codigo, usuario_t** vector_usuarios, size_t cantidad_usuarios){

    size_t id_usuario_que_paga = (size_t)atoi(pila_desapilar(pila_codigo));
    size_t id_usuario_que_recibe = (size_t)atoi(pila_desapilar(pila_codigo));
    double monto = (double)atof(pila_desapilar(pila_codigo));

    usuario_t* usuario_que_paga = buscar_usuario(id_usuario_que_paga, vector_usuarios, cantidad_usuarios);
    usuario_t* usuario_que_recibe = buscar_usuario(id_usuario_que_recibe, vector_usuarios, cantidad_usuarios);

    //Modifica los pagos
    usuario_que_paga->saldo = usuario_que_paga->saldo - monto;
    usuario_que_recibe->saldo = usuario_que_recibe->saldo + monto;
    return true;
}

//Funciones de linea de comando (Usuario)

int agregar_pago(pago_t* pago, lista_t* cola_de_pagos){
    if(lista_esta_vacia(cola_de_pagos)){
        lista_insertar_primero(cola_de_pagos, pago);
    } else {
        lista_insertar_ultimo(cola_de_pagos, pago);
    }
    return 0;
}

int pagos_pendientes(lista_t* cola_de_pagos){
    pago_t* pago_aux;
    lista_iter_t* iter = lista_iter_crear(cola_de_pagos);
    double monto_total = 0;

    while(!lista_iter_al_final(iter)){
        pago_aux = lista_iter_ver_actual(iter);
        lista_iter_avanzar(iter);
        monto_total = monto_total + pago_aux->monto;
    }
    fprintf(stdout, "%lu, %.3f\n", lista_largo(cola_de_pagos), monto_total);
    lista_iter_destruir(iter);
    return 0;
}

int procesar(lista_t* cola_de_pagos, usuario_t** vector_usuarios, size_t cantidad_usuarios){
    pila_t* pila_codigo = pila_crear(); //Manejar error no se puede crear pila

    //obtengo el pago
    pago_t* pago_procesar = lista_borrar_primero(cola_de_pagos); //Manejar caso lista este vacia

    //printf("%s",pago_procesar->codigo);
    char** codigo_parseado = split(pago_procesar->codigo, ';');

    size_t i = 0;
    while(codigo_parseado[i] != NULL){
        if(strcmp("validar_usuario",codigo_parseado[i]) == 0){
            bool ok = validar_usuario(pila_codigo, vector_usuarios, cantidad_usuarios);
            if(!ok){
                fprintf(stderr,"Error en pago %zu\n",pago_procesar->id);
            }
        }
        if(strcmp("validar_pago",codigo_parseado[i]) == 0){
            bool ok = validar_pago(pila_codigo, vector_usuarios, cantidad_usuarios);
            if(!ok){
                fprintf(stderr,"Error en pago %zu\n",pago_procesar->id);
            }
        }
        if(strcmp("pagar",codigo_parseado[i]) == 0){
            pagar(pila_codigo, vector_usuarios, cantidad_usuarios);
        }
        pila_apilar(pila_codigo, codigo_parseado[i]);
        i++;
    }
    pila_destruir(pila_codigo);
    return 0;
}

int guardar_cuentas(char* nombre_archivo, usuario_t** vector_usuarios){

    FILE* f_cuentas_usuarios = fopen(nombre_archivo,"w"); //Validar que se pueda abrir

    size_t i = 0;
    while(vector_usuarios[i] != NULL){
        fprintf(f_cuentas_usuarios, "%zu,%.3f,%s",vector_usuarios[i]->id, vector_usuarios[i]->saldo, vector_usuarios[i]->coordenadas);
        i++;
    }
    fclose(f_cuentas_usuarios);
    return 0;
}

//Interfaz

void interfaz(lista_t* cola_de_pagos, usuario_t** vector_usuarios, size_t cantidad_usuarios){

    //Utilidad getline
    char* linea = NULL;
    size_t capacidad = 0;
    ssize_t leidos;

    while((leidos = getline(&linea,&capacidad,stdin)) > 0){

        //Boro el ultimo '\n'
        linea[leidos - 1] = '\0';
        char** leidos_stdin = split(linea, ' ');

        if(strcmp("agregar_pago",leidos_stdin[0]) == 0){
            int parametros_leidos = contar_parametros_leidos(leidos_stdin);
            if(parametros_leidos != 4){
                fprintf(stderr,"Error en comando agregar_pago\n");
                return;
            }
            pago_t* pago = cargar_pago(leidos_stdin[1], leidos_stdin[2], leidos_stdin[3]);
            agregar_pago(pago, cola_de_pagos);
            fprintf(stdout, "OK \n");
        }

        if(strcmp("pagos_pendientes",leidos_stdin[0]) == 0){
            int parametros_leidos = contar_parametros_leidos(leidos_stdin);
            if(parametros_leidos != 1){
                fprintf(stderr,"Error en comando pagos_pendientes\n");
                return;
            }
            pagos_pendientes(cola_de_pagos);
            fprintf(stdout, "OK \n");
        }

        if(strcmp("procesar",leidos_stdin[0]) == 0){
            int parametros_leidos = contar_parametros_leidos(leidos_stdin);
            if(parametros_leidos != 2){
                fprintf(stderr,"Error en comando procesar\n");
                return;
            }

            size_t numero_procesar = (size_t)atoi(leidos_stdin[1]);
            size_t i = 0;
            while(i < numero_procesar || !lista_esta_vacia(cola_de_pagos)){
                procesar(cola_de_pagos, vector_usuarios, cantidad_usuarios);
                i++;
            }
            fprintf(stdout, "OK \n");
        }

        if(strcmp("guardar_cuentas",leidos_stdin[0]) == 0){
            int parametros_leidos = contar_parametros_leidos(leidos_stdin);
            if(parametros_leidos != 2){
                fprintf(stderr,"Error en comando guardar_cuentas\n");
                return;
            }

            char* nombre_archivo = leidos_stdin[1];
            borrar_salto_de_linea(nombre_archivo);
            guardar_cuentas(nombre_archivo, vector_usuarios);
            fprintf(stdout, "OK \n");
        }

        if(strcmp("finalizar", leidos_stdin[0]) == 0){
            int parametros_leidos = contar_parametros_leidos(leidos_stdin);
            if(parametros_leidos != 1){
                fprintf(stderr,"Error en comando finalizar\n");
                return;
            }
            lista_destruir(cola_de_pagos, NULL);
            free_strv(leidos_stdin);
            fprintf(stdout, "OK \n");
            return;
        }
    }
}

//Main

int main(int argc, char *argv[]){

    //Borrar esto, es para probar
    printf("Bienvenido a Wachencoin Service LTDA\n");

    //Creo la cola de pagos
    lista_t* cola_de_pagos = lista_crear(); //Manejar error lista

    //Creo un vector de usuarios
    size_t cantidad_usuarios;
    usuario_t** vector_usuarios = cargar_usuarios_a_vector(argv[1], &cantidad_usuarios);

    //Llevo el usuario a la interfaz
    interfaz(cola_de_pagos, vector_usuarios, cantidad_usuarios);

    return 0;
}