/**
 * @param email
 * @param password
 * @return Usuario
 */
Usuario* GestorUsuarios::login(QString email, QByteArray password) {
    QString error="";
    //Obtengo el usuario con ese correo si no existe retorno NULL
    Usuario *user = gestorDB->cargarUsuario(email);
    if(user==NULL){
        return NULL;
    }

    //Comparo las contraseñas

    if(password!=user->getPassword())
        return NULL;
    else{
     //Registro el inicio de sesión
        Auditoria* aud=new Auditoria();
        aud->setFecha(QDateTime::currentDateTime().toString(Qt::ISODate));
        aud->setPc(QHostInfo::localHostName());
        QVector<Auditoria*> auditorias=user->getAuditorias();
        auditorias.push_back(aud);
        user->setAuditorias(auditorias);
        //Guardo para que quede registrado el nuevo inicio de sesión
        gestorDB->saveUsuario(user);
        this->setActual(user);
        //retorno el usuario cargado
        return user;
    }
}

//Definición de los métodos de la clase Pedido
Pedido::Pedido (Usuario_Pedido& up, Pedido_Articulo& pa, Usuario& u, const Tarjeta& t, const Fecha& f) : num_(N_pedidos + 1), tarjeta_(&t), fecha_(f), total_(0) {
    if (t.caducidad() < f) throw Tarjeta::Caducada(t.caducidad());
    if (&u != t.titular()) throw Pedido::Impostor(u);
    Fecha actual = Fecha();
    for(auto& i : u.compra()) {
        if (LibroDigital* ld = dynamic_cast<LibroDigital*> (i.first)) {
            if (ld->f_expir() < actual)
                u.compra(*ld, 0);
        }
        else {
            ArticuloAlmacenable* pa = dynamic_cast<ArticuloAlmacenable*> (i.first);
            if (i.second > pa->stock()){
                Articulo& aux = *(i.first);
                vaciar_carrito(u);
                throw Pedido::SinStock(aux);
            }
        }
    }
    if (u.n_articulos() == 0) throw Pedido::Vacio(u);
    for(auto& i : u.compra()) {
        if (ArticuloAlmacenable* aa = dynamic_cast<ArticuloAlmacenable*> (i.first)){
            aa->stock() = aa->stock() - 1;
        }
        pa.pedir (*this, *(i.first), (i.first)->precio(), i.second);
        total_ += (i.first)->precio() * i.second;
        u.compra (*(i.first), 0);
    }
    up.asocia(u, *this);
    N_pedidos++;
}

Tarjeta::~Tarjeta()
{
        if(titular_ !=  nullptr)
        {
                Usuario* usaux = const_cast<Usuario*>(titular_);
                usaux->no_es_titular_de(*this);
        }
}

Tarjeta::Tarjeta(Numero n, Usuario& us, Fecha fecha) : num(n), titular_(&us){
  titular_facial_ = us.nombre();
  titular_facial_ += " ";
  titular_facial_ += us.apellidos();
  
  Fecha actual;
  if(actual > fecha) throw Tarjeta::Caducada(fecha);
  caducidad_ = fecha;
  
  us.es_titular_de(*this);
}

/// GET: /usuario
RequestResult Request_GET_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	auto qdict = parseQueryParams(qparams);
	Usuario usr;
	if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"]) || !db->loadUsuario(uriparams, usr)) {
		ret.code = 401;
		ret.data = "{\"error\": \"token invalido\" }";
	}else{
		ret.data = usr.asJson();
	}
	return ret;
}

void TestConversacion::testSerializacionDeDatosUnaConversacion() {
	Usuario* user = new Usuario("Pepe", "foto", "1568017070");
	Usuario* user2 = new Usuario("Jose", "foto2", "156801515");

	BaseDeDatos* db = BaseDeDatos::getInstance();
	db->setUsuario(user);
	db->setUsuario(user2);

	vector<Usuario*> usuarios;
	usuarios.push_back(user);
	usuarios.push_back(user2);

	vector<Mensaje*> mensajes;
	mensajes.push_back(new Mensaje("cuerpo mensaje 1", "asdasd", "fecha1"));
	mensajes.push_back(new Mensaje("cuerpo mensaje 2", "asdasd2", "fecha2"));

	Conversacion* conversacion = new Conversacion(usuarios, mensajes);
	string conversacionSerializada = conversacion->serializar();

	Conversacion* conv2 = new Conversacion(conversacionSerializada);
	vector<Mensaje*> mensajesDeserealizados = conv2->getMensajes();

	vector<Usuario*> usuariosDeserealizados = conv2->getUsuarios();

	CPPUNIT_ASSERT(
			mensajes[0]->getCuerpo() == mensajesDeserealizados[0]->getCuerpo());
	CPPUNIT_ASSERT(
			mensajes[1]->getCuerpo() == mensajesDeserealizados[1]->getCuerpo());
	CPPUNIT_ASSERT(
			mensajes[0]->getIdUsuarioEmisor()
					== mensajesDeserealizados[0]->getIdUsuarioEmisor());
	CPPUNIT_ASSERT(
			mensajes[1]->getIdUsuarioEmisor()
					== mensajesDeserealizados[1]->getIdUsuarioEmisor());
	CPPUNIT_ASSERT(
			mensajes[0]->getFecha() == mensajesDeserealizados[0]->getFecha());
	CPPUNIT_ASSERT(
			mensajes[1]->getFecha() == mensajesDeserealizados[1]->getFecha());

	CPPUNIT_ASSERT(user->getNombre() == usuariosDeserealizados[0]->getNombre());
	CPPUNIT_ASSERT(user->getId() == usuariosDeserealizados[0]->getId());

	CPPUNIT_ASSERT(
			user2->getNombre() == usuariosDeserealizados[1]->getNombre());
	CPPUNIT_ASSERT(user2->getId() == usuariosDeserealizados[1]->getId());

	delete user;
	delete user2;
	delete conversacion;
	delete conv2;

}

void imprimir_opciones(Usuario sesion){
	ifstream in("db/perfiles.db");
	 string s,reg;
	 int contador;
	 list<Usuario> usuarios;
	 // Cargamos los usuarios guardados
	 contador = 0;
	 while (getline(in,reg)){	
		Usuario u;
		u.decodificar(reg);
		usuarios.push_back(u);
		contador = contador + 1;
	 }
};

/* Metodos para mantenimiento */
void listar_usuarios(){
	string registro;
	ifstream in("db/usuarios.db");
	cout << "+----------+--------------------+" << endl;
	cout << "| CODIGO   | NOMBRE COMPLETO    |" << endl;
	cout << "+----------+--------------------+" << endl;
	while (getline(in,registro)){	
		Usuario u;
		u.decodificar(registro);
		u.iniciar();
		u.to_string();
	}
	cout << "+----------+--------------------+" << endl;
};

Tarjeta::Tarjeta(Tarjeta::Tipo t, const Numero& num, Usuario& u,const Fecha& f)
:tipo_{t}, num_{num}, titular_{&u}, f_cad_{f}
{

        if(caducidad() < Fecha())
                throw Tarjeta::Caducada(caducidad());
        else
        {
                titular_facial_= u.nombre() +" "+u.apellidos();

                for(int i = 0; i<titular_facial_.length(); i++)
                        titular_facial_[i]= std::toupper(titular_facial_[i]);

                u.es_titular_de(*this);
        }
}

/**
 * Se encarga de calcular en que lugar se encuentra el cliente
 * en base a sus coordenadas geográficas y los lugares precargados.
 *
 */
void Servicio::checkIn() {
	Json::Value coordenadas;
	string latitud = this->getParametro(keyLatitud, keyDefault);
	string longitud = this->getParametro(keyLongitud, keyDefault);
	coordenadas["latitud"] = atof(latitud.c_str());
	coordenadas["longitud"] = atof(longitud.c_str());

	Usuario* usuario = this->obtenerUsuario();
	if (usuario->getId() != keyIdUsuarioNoEncontrado) {
		string localizacion = Localizacion::calcularUbicacion(coordenadas)+" "+fechaYhoraActual();
		usuario->setLocalizacion(localizacion);
		usuario->persistir();
		this->responder(localizacion, true);
	} else {
		this->responder("el usuario no existe.", false);
	}
}

/**
 * Obtiene los contactos que se encuentran registrados en el sistemas y estan conectados,
 * a partir de numeros de telefono que recibe
 *
 */
void Servicio::obtenerContactos() {
	Json::Value contactosTelefonoValue = this->getParametroArray(
	keyContantosTelefono, keyDefault);
	vector<string> contactosTelefono = StringUtil::jsonValueToVector(
			contactosTelefonoValue);

	Json::Value respuesta;
	int counter = 0;
	for (unsigned i = 0; i < contactosTelefono.size(); i++) {
		string telefonoActual = contactosTelefono[i];
		Usuario* usuario = Usuario::obtenerPorTelefono(telefonoActual);

		//Agrego los usuarios que estan registrados y que se encuentran conectados

		if (usuario->getId() != keyIdUsuarioNoEncontrado
				&& usuario->getEstadoConexion()) {
			respuesta["contactos"][counter][keyNombre] = usuario->getNombre();
			respuesta["contactos"][counter][keyTelefono] =
					usuario->getTelefono();
			respuesta["contactos"][counter][keyFotoDePerfil] =
					usuario->getFotoDePerfil();
			respuesta["contactos"][counter][keyLocalizacion] = usuario->getLocalizacion();
			counter++;
		}
	}

	this->responder(respuesta.toStyledString(), true);
}

/// POST: /usuario
RequestResult Request_POST_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	Usuario user;
	// Parseamos el JSON para cargar los datos posteados
	auto js = JSONParse(body);
	user.load(js);
	// Cargamos el usuario del uri
	user.id = uriparams;
	std::string err_str;
	if(db->createUsuario(user, err_str)) {
		ret.code = 201;
	}else{
		log.msg(LOG_TYPE::INFO, std::string("Error creando usuario `") + user.id + "`");
		ret.code = 401;
                ret.data = std::string("{ \"error\": \"") + err_str + "\" }";
	}
	return ret;
}

/// PUT: /usuario
RequestResult Request_PUT_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	auto qdict = parseQueryParams(qparams);
	Usuario usr;
	// Debe pasar la clave tambien
	if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"])) {
		ret.code = 401;
		ret.data = "{\"error\": \"token invalido\" }";
		return ret;
	}
	if(uriparams != qdict["r_user"]) {
		ret.code = 401;
		ret.data = "{\"error\": \"permiso denegado\" }";
		return ret;
	}
	if(!db->loadUsuario(uriparams, usr)) {
		ret.code = 500;
		ret.data = "{\"error\": \"error cargando usuario\" }";
		return ret;
	}
	if(qdict["password"] != usr.password) {
		ret.code = 401;
		ret.data = "{\"error\": \"password invalido\" }";
		return ret;
	}
	// Editamos los valores que nos pasaron (si los pasaron)
	auto js = JSONParse(body);
	usr.load(js);
	// Guardamos el usuario
	if(!db->saveUsuario(usr)) {
		// TODO: desdoblar en los distintos
		ret.code = 401;
		ret.data = "{ \"error\": \"atributos invalidos\" }";
	}else{
		ret.code = 201;
	}
	return ret;
}

// Metodo que retorna el usuario de sesion
Usuario login(list<Usuario> usuarios){
	/* Metodo que genera sesion de usuario correctamente logueado */
  list<Usuario>::iterator it;
  string user;
  string pass;
  int ok = 0;
  Usuario sesion; 
  // comparar hasta encontrar igualdades y cambiar ok a 1
  while (ok == 0){
  cout << "Ingrese su usuario:";
  cin >> user;
  cout << "Ingrese su password:";
  cin >> pass;
	it = usuarios.begin();
	// Hasta recorrer todos los emementos
	while(it != usuarios.end()){ 
		if (user.compare(it->username) == 0) {
			// Reiniciamos en iterador
			it = usuarios.begin();
			// Comparamos los passwords
			while(it != usuarios.end()){
				if (pass.compare(it->password) == 0){
					// Valores correctos
					ok = 1;
  					sesion.decodificar(it->text_encoded);
  					cout << "Bienvenido " << sesion.full_name << endl;	
					break;
				}
				it++;
			}
			break;
		}
		it++;
	}
  }
  return sesion;
};

int main(){
	/* Metodo principal */
	list<Usuario> usuarios;
	Usuario sesion;
	string s,reg;
	int contador;
	// Cargamos los usuarios guardados
	//contador = 0;
	ifstream in("db/usuarios.db");
	while (getline(in,reg)){	
		Usuario u;
		u.decodificar(reg);
		usuarios.push_back(u);
	}
	// Usando comandos unix
	system("clear"); // linux
	system("cls"); // linux
	imprimir_logo();
	pausa();
	sesion = login(usuarios); 
	sesion.iniciar();
	menu_principal(sesion);
	return 0;
}

void StrategyNotificaciones::notificar(Consulta* consulta)
{
	stringstream notificacion;

	string tipoConsulta = (consulta->tipo() == TipoConsulta::comun) ? "COMUN" : "URGENCIA";

	Usuario* medico   = consulta->medico();
	Usuario* paciente = consulta->paciente();

	notificacion << "Paciente diagnosticado: " << paciente->getNombre() << " " << paciente->getApellido() << endl
	             << "Médico notificado: " << medico->getNombre() << " " << medico->getApellido() << endl
	             << "Tipo de consulta: " << tipoConsulta << endl
	             << "Hora de consulta: " << consulta->fechaConsulta() << endl;

	_notificaciones.push_back(notificacion.str());
}

/**
 * Registra un usuario en el sistema
 *
 */
void Servicio::registrarUsuario() {

	Usuario* user = this->obtenerUsuario();
	if (user->getId() != keyIdUsuarioNoEncontrado) {
		//El usuario ya existe. Devuelvo error
		Loger::getLoger()->warn(
				"Se intento registrar un usuario ya existente. Id: "
						+ user->getId());
		this->responder("El usuario ya existe", false);
	} else {
		string nombre = this->getParametro(keyNombre, keyDefault);
		string fotoPerfil = this->getParametro(keyFotoDePerfil, keyDefault);
		string telefono = this->getParametro(keyTelefono, keyDefault);
		string password = this->getParametro(keyPassword, keyDefault);

		Usuario* user = new Usuario(nombre, telefono, password);

		user->persistir();
		this->responder("Usuario registrado correctamente", true);
		Loger::getLoger()->info(
				"Se registro el usuario con Id: " + user->getId());
		delete user;
	}
}

Tarjeta::~Tarjeta(){
  Usuario* user = const_cast<Usuario*>(titular_);
  if(user != 0) user->no_es_titular_de(*this);
}

int menu_principal(Usuario sesion){
	/* Menu pricipal según perfil de usuario */
  int opcion = 1;
  list<Permiso> mis_permisos = sesion.permisos;
  list<Permiso>::iterator it;
	while (opcion!=0){
  		it = mis_permisos.begin();
	  //Mostrando la lista de modulos segun permisos
	  cout << "+---------------------+"<< endl;
	  cout << "|---MENU PRINCIPAL----|"<< endl;
	  cout << "+---------------------+"<< endl;
	  cout << "|" + pull_left(" 0 SALIR.",21)+ "|"<< endl;
	  while(it != mis_permisos.end()){
			cout << "| " << pull_left(it->codigo + " " + it->descripcion + ".",20) << "|"<< endl;
			it++;
		}
	  cout << "+---------------------+"<< endl;
		cout << "Seleccionar:";
		cin >> opcion;
  		if (sesion.tiene_permiso(opcion)){
			switch(opcion){	
				 case 0 :
				 	salir();
				 	break;
				 case 1 :
				 	inicio();
				  	break;
				 case 2 :
				  	pedidos();
				  	break;
				 case 3 :
				  	pagos();
				  	break;
				 case 4 :
				  	stock();

				  	break;
				 case 5 :
				  	finanzas();
				  	break;
				 case 6 :
				 	cout << "Modulo de mantenimiento" << endl;
				  	mantenimiento(sesion);
	 
				  	break;
				 case 7 :
				  	miscelaneos();
				  	break;
				 default:
			  		cout << "Opcion inválida." << endl;
		 	}
  		}else{
  			if (opcion!=0){
  				cout << "Ingrese una opción válida." << endl;
  			}else{
  				salir();
  			}
  		}
	}

  return 1;
};

/**
 * Devuelve el id de una conversacion a partir de dos telefonos
 *
 */
void Servicio::obtenerIdConversacion() {
	string telefonoUsuarioEmisor = this->getParametro(keyTelefonoEmisor,
			keyDefault);
	;
	string telefonoUsuarioRecceptor = this->getParametro(keyTelefonoReceptor,
			keyDefault);

	Usuario* usuarioEmisor = Usuario::obtenerPorTelefono(telefonoUsuarioEmisor);
	Usuario* usuarioReceptor = Usuario::obtenerPorTelefono(
			telefonoUsuarioRecceptor);

	if (usuarioEmisor->getId() != keyIdUsuarioNoEncontrado
			&& usuarioReceptor->getId() != keyIdUsuarioNoEncontrado) {
		vector<Mensaje*> mensajes;
		vector<Usuario*> usuarios;
		usuarios.push_back(usuarioEmisor);
		usuarios.push_back(usuarioReceptor);
		Conversacion *conversacion = Conversacion::obtener(
				usuarioEmisor->getId() + "-" + usuarioReceptor->getId());
		if (conversacion->getId() == keyIdConversacionNoEncontrada) {
			conversacion = Conversacion::obtener(
					usuarioReceptor->getId() + "-" + usuarioEmisor->getId());
		}
		string idConversacion = conversacion->getId();
		if (idConversacion != keyIdUsuarioNoEncontrado) {
			this->responder(idConversacion, true);
		} else {
			//Si la conversacion no existe devuelvo como id uno default para estos dos usuarios
			Conversacion* conversacion = new Conversacion(usuarios, mensajes);
			string idConversacion = conversacion->getId();

			this->responder(idConversacion, false);
		}
	} else {
		Usuario* user;
		if (usuarioEmisor->getId() == keyIdUsuarioNoEncontrado) {
			user = usuarioEmisor;
		} else {
			user = usuarioReceptor;
		}
		string msj_warn = "Usuario " + user->getNombre()
				+ " no se encuentra registrado en el sistema";

		Loger::getLoger()->warn(msj_warn);
		this->responder(msj_warn, false);
	}

	delete usuarioEmisor;
	delete usuarioReceptor;
}