use crate::routes::models::object::ObjectModelDisplay;
use crate::routes::models::relation::RelationModelDisplay;
use crate::session_ext::SessionExt;
use crate::tera_ext::TeraExt;
use crate::TERA;
use actix_session::Session;
use actix_web::Responder;
use yopa::model::{PropertyModel, RelationModel, ObjectModel};

pub(crate) mod object;
pub(crate) mod property;
pub(crate) mod relation;

#[get("/models")]
pub(crate) async fn list(
    session: Session,
    store: crate::YopaStoreWrapper,
) -> actix_web::Result<impl Responder> {
    let rg = store.read().await;

    let models_iter = rg.get_object_models();

    // object and relation props
    let mut model_props = rg.get_grouped_prop_models();

    let mut model_relations = rg.get_grouped_relation_models();
    let mut model_rec_relations = rg.get_grouped_reciprocal_relation_models();

    let mut models = vec![];
    for om in models_iter {
        let relations = model_relations.remove(&om.id).unwrap_or_default();
        let mut relations = relations
            .into_iter()
            .map(|rm| {
                let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
                rprops.sort_by(PropertyModel::order_refs);

                RelationModelDisplay {
                    model: rm,
                    related_name: rg.get_model_name(rm.related),
                    properties: rprops,
                }
            })
            .collect::<Vec<_>>();
        relations.sort_by(|a, b| RelationModel::order_refs(&a.model, &b.model));

        // Relations coming INTO this model
        let reciprocal_relations = model_rec_relations.remove(&om.id).unwrap_or_default();
        let mut reciprocal_relations = reciprocal_relations
            .into_iter()
            .map(|rm| {
                let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
                rprops.sort_by(PropertyModel::order_refs);

                RelationModelDisplay {
                    model: rm,
                    related_name: rg.get_model_name(rm.object),
                    properties: rprops,
                }
            })
            .collect::<Vec<_>>();
        reciprocal_relations.sort_by(|a, b| RelationModel::reciprocal_order_refs(&a.model, &b.model));

        let mut properties = model_props.remove(&om.id).unwrap_or_default();
        properties.sort_by(PropertyModel::order_refs);

        models.push(ObjectModelDisplay {
            id: om.id,
            name: &om.name,
            model: &om,
            properties,
            relations,
            reciprocal_relations,
        })
    }

    models.sort_by(|a, b| ObjectModel::order_refs(&a.model, &b.model));

    let mut ctx = tera::Context::new();
    ctx.insert("models", &models);
    session.render_flash(&mut ctx);

    TERA.build_response("models/index", &ctx)
}