import time

from typing import List, Any, Optional, Union

from fastapi import APIRouter, Depends, Request, HTTPException, Body
from sqlalchemy.orm import Session
from sqlalchemy import and_, or_, select, text

from presupuestov1 import model, schema, constant, schemas, models, search
from presupuestov1.routers._decorators import not_found


router_objeto = APIRouter(
	prefix='/objeto',
	tags=['objeto'],
)

router_acteco = APIRouter(
	prefix='/acteco',
	tags=['acteco'],
)

router_finfun = APIRouter(
	prefix='/finfun',
	tags=['finfun'],
)


###############################################################################
# GET
###############################################################################

@router_objeto.get('/clasificador', response_model=List[schemas.classifier.ClasObjetos])
@not_found
def fetch_objeto_classifier(db: Session = Depends(model.get_db)):
	return _fetch_classifier('objeto', db)


@router_acteco.get('/clasificador', response_model=List[schemas.classifier.ClasActeco])
@not_found
def fetch_acteco_classifier(db: Session = Depends(model.get_db)):
	return _fetch_classifier('acteco', db)


@router_finfun.get('/clasificador', response_model=List[schemas.classifier.ClasFinfun])
@not_found
def fetch_finfun_classifier(db: Session = Depends(model.get_db)):
	return _fetch_classifier('finfun', db)


@router_objeto.get('/{object_id}', response_model=schemas.objeto.ClasObjetosEstados)
@not_found
def fetch_objeto_estado(
	object_id: str,
	db: Session = Depends(model.get_db),
):
	ClasEstado = models.objeto.ObjetoEstado
	estados = db.query(ClasEstado).filter(
		ClasEstado.objeto == object_id,
	).all()

	ClasObjetos = models.classifier.ClasObjetos
	objeto = db.query(ClasObjetos).filter(
		ClasObjetos.objeto == object_id
	).one()

	setattr(objeto, 'estados', estados)
	return objeto


@router_objeto.get('/{object_id}/entidades', response_model=List[schemas.objeto.ObjetoEntidad])
@not_found
def fetch_objeto_entidad(
	object_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.objeto.ObjetoEntidad

	return db.execute(
		select(*model.model_columns(ClasObjetos)).where(
			ClasObjetos.objeto == object_id,
			ClasObjetos.gestion == gestion
		)
	).mappings().all()


@router_objeto.get('/{object_id}/ubigeos', response_model=List[schemas.objeto.ObjetoUbigeo])
@not_found
def fetch_objeto_ubigeo(
	object_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.objeto.ObjetoUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.objeto == object_id,
		ClasObjetos.gestion == gestion
	).all()


@router_objeto.get('/{object_id}/entidades/map', response_model=List[schemas.treemap.TreemapObjetoSingle])
@not_found
def fetch_objeto_treemap(
	object_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	Treemap = models.treemap.TreemapObjeto
	return models.treemap.get_clas_entities(
		[
	        Treemap.objeto == object_id
		], db, query, Treemap, 'entidad'
	)

@router_objeto.get('/{object_id}/entidades/{entidad_id}', response_model=List[schemas.objeto.ObjetoEntidad])
@not_found
def fetch_objeto_entidad_single(
	object_id: str,
	entidad_id: int,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.objeto.ObjetoEntidad

	return db.query(ClasObjetos).filter(
		ClasObjetos.objeto == object_id,
		ClasObjetos.entidad == entidad_id
	).all()


@router_objeto.get('/{object_id}/ubigeos/{ubigeo_id}', response_model=List[schemas.objeto.ObjetoUbigeo])
@not_found
def fetch_objeto_ubigeo_single(
	object_id: str,
	ubigeo_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.objeto.ObjetoUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.objeto == object_id,
		ClasObjetos.ubigeo == ubigeo_id
	).all()


@router_acteco.get('/{acteco_id}', response_model=schemas.acteco.ClasActecoEstados)
@not_found
def fetch_acteco_estado(
	acteco_id: str,
	db: Session = Depends(model.get_db),
):
	ClasEstado = models.acteco.ActecoEstado
	estados = db.query(ClasEstado).filter(
		ClasEstado.acteco == acteco_id,
	).all()

	ClasActeco = models.classifier.ClasActeco
	acteco = db.query(ClasActeco).filter(
		ClasActeco.acteco == acteco_id
	).one()

	setattr(acteco, 'estados', estados)
	return acteco


@router_acteco.get('/{acteco_id}/entidades', response_model=List[schemas.acteco.ActecoEntidad])
@not_found
def fetch_acteco_entidad(
	acteco_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.acteco.ActecoEntidad

	return db.execute(
		select(*model.model_columns(ClasObjetos)).where(
			ClasObjetos.acteco == acteco_id,
			ClasObjetos.gestion == gestion
		)
	).mappings().all()


@router_acteco.get('/{acteco_id}/ubigeos', response_model=List[schemas.acteco.ActecoUbigeo])
@not_found
def fetch_acteco_ubigeo(
	acteco_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.acteco.ActecoUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.acteco == acteco_id,
		ClasObjetos.gestion == gestion
	).all()


@router_acteco.get('/{acteco_id}/entidades/map', response_model=List[schemas.treemap.TreemapActecoSingle])
@not_found
def fetch_acteco_treemap(
	acteco_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	Treemap = models.treemap.TreemapActeco
	return models.treemap.get_clas_entities(
		[
	        Treemap.acteco == acteco_id
		], db, query, Treemap, 'entidad'
	)


@router_acteco.get('/{acteco_id}/entidades/{entidad_id}', response_model=List[schemas.acteco.ActecoEntidad])
@not_found
def fetch_acteco_entidad_single(
	acteco_id: str,
	entidad_id: int,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.acteco.ActecoEntidad

	return db.query(ClasObjetos).filter(
		ClasObjetos.acteco == acteco_id,
		ClasObjetos.entidad == entidad_id
	).all()


@router_acteco.get('/{acteco_id}/ubigeos/{ubigeo_id}', response_model=List[schemas.acteco.ActecoUbigeo])
@not_found
def fetch_acteco_ubigeo_single(
	acteco_id: str,
	ubigeo_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.acteco.ActecoUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.acteco == acteco_id,
		ClasObjetos.ubigeo == ubigeo_id
	).all()


@router_finfun.get('/{finfun_id}', response_model=schemas.finfun.ClasFinfunEstados)
@not_found
def fetch_finfun_estado(
	finfun_id: str,
	db: Session = Depends(model.get_db),
):
	ClasEstado = models.finfun.FinfunEstado
	estados = db.query(ClasEstado).filter(
		ClasEstado.finfun == finfun_id
	).all()

	ClasFinfun = models.classifier.ClasFinfun
	finfun = db.query(ClasFinfun).filter(
		ClasFinfun.finfun == finfun_id
	).one()

	setattr(finfun, 'estados', estados)
	return finfun


@router_finfun.get('/{finfun_id}/entidades', response_model=List[schemas.finfun.FinfunEntidad])
@not_found
def fetch_finfun_entidad(
	finfun_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.finfun.FinfunEntidad

	return db.execute(
		select(*model.model_columns(ClasObjetos)).where(
			ClasObjetos.finfun == finfun_id,
			ClasObjetos.gestion == gestion
		)
	).mappings().all()


@router_finfun.get('/{finfun_id}/ubigeos', response_model=List[schemas.finfun.FinfunUbigeo])
@not_found
def fetch_finfun_ubigeo(
	finfun_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	gestion = query.gestion or 0
	ClasObjetos = models.finfun.FinfunUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.finfun == finfun_id,
		ClasObjetos.gestion == gestion
	).all()


@router_finfun.get('/{finfun_id}/entidades/map', response_model=List[schemas.treemap.TreemapFinFunSingle])
@not_found
def fetch_finfun_treemap(
	finfun_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	Treemap = models.treemap.TreemapFinFun
	return models.treemap.get_clas_entities(
		[
	        Treemap.finfun == finfun_id
		], db, query, Treemap, 'entidad'
	)


@router_finfun.get('/{finfun_id}/entidades/{entidad_id}', response_model=List[schemas.finfun.FinfunEntidad])
@not_found
def fetch_finfun_entidad_single(
	finfun_id: str,
	entidad_id: int,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.finfun.FinfunEntidad

	return db.query(ClasObjetos).filter(
		ClasObjetos.finfun == finfun_id,
		ClasObjetos.entidad == entidad_id
	).all()


@router_finfun.get('/{finfun_id}/ubigeos/{ubigeo_id}', response_model=List[schemas.finfun.FinfunUbigeo])
@not_found
def fetch_finfun_ubigeo_single(
	finfun_id: str,
	ubigeo_id: str,
	db: Session = Depends(model.get_db),
	query: schema.QueryParams = Depends(),
):
	ClasObjetos = models.finfun.FinfunUbigeo

	return db.query(ClasObjetos).filter(
		ClasObjetos.finfun == finfun_id,
		ClasObjetos.ubigeo == ubigeo_id
	).all()


###############################################################################
# priv
###############################################################################

def _fetch_classifier(clas, db):
	ClasObject = {
		'objeto': models.classifier.ClasObjetos,
		'acteco': models.classifier.ClasActeco,
		'finfun': models.classifier.ClasFinfun,
		'ubigeo': models.classifier.ClasGeografico,
	}[clas]
	return db.query(ClasObject).all()