use super::{render_error, PaginatedQuery, ProfileQuery};
use crate::{
    assets::initial_context, check_user_blocked_or_private, get_lang, get_user_from_token,
    ignore_users_gen, State,
};
use axum::{
    Extension,
    extract::{Path, Query},
    response::{Html, IntoResponse},
};
use axum_extra::extract::CookieJar;
use serde::Deserialize;
use tera::Context;
use tetratto_core::model::{auth::User, communities::Community, permissions::FinePermission, Error};
use tetratto_shared::hash::hash;
use contrasted::{Color, MINIMUM_CONTRAST_THRESHOLD};

#[derive(Deserialize)]
pub struct SettingsProps {
    #[serde(default)]
    pub username: String,
    #[serde(default)]
    pub page: usize,
}

/// `/settings`
pub async fn settings_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Query(req): Query<SettingsProps>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = match get_user_from_token!(jar, data.0) {
        Some(ua) => ua,
        None => {
            return Err(Html(
                render_error(Error::NotAllowed, &jar, &data, &None).await,
            ));
        }
    };

    let profile = if req.username.is_empty() | !user.permissions.check(FinePermission::MANAGE_USERS)
    {
        user.clone()
    } else {
        match data.0.get_user_by_username(&req.username).await {
            Ok(ua) => ua,
            Err(e) => {
                return Err(Html(render_error(e, &jar, &data, &None).await));
            }
        }
    };

    let stacks = match data.0.get_stacks_by_user(profile.id).await {
        Ok(ua) => ua,
        Err(e) => {
            return Err(Html(render_error(e, &jar, &data, &None).await));
        }
    };

    let following = match data
        .0
        .fill_userfollows_with_receiver(
            data.0
                .get_userfollows_by_initiator_all(profile.id)
                .await
                .unwrap_or(Vec::new()),
        )
        .await
    {
        Ok(r) => r,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &None).await)),
    };

    let blocks = match data
        .0
        .fill_userblocks_receivers(data.0.get_userblocks_by_initiator(profile.id).await)
        .await
    {
        Ok(r) => r,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &None).await)),
    };

    let stackblocks = {
        let mut out = Vec::new();

        for block in data.0.get_stackblocks_by_initiator(profile.id).await {
            out.push(match data.0.get_stack_by_id(block.stack).await {
                Ok(s) => s,
                Err(_) => continue,
            });
        }

        out
    };

    let uploads = match data.0.get_uploads_by_owner(profile.id, 12, req.page).await {
        Ok(ua) => ua,
        Err(e) => {
            return Err(Html(render_error(e, &jar, &data, &None).await));
        }
    };

    let tokens = profile.tokens.clone();

    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;

    context.insert("profile", &profile);
    context.insert("page", &req.page);
    context.insert("uploads", &uploads);
    context.insert("stacks", &stacks);
    context.insert("following", &following);
    context.insert("blocks", &blocks);
    context.insert("stackblocks", &stackblocks);
    context.insert(
        "user_tokens_serde",
        &serde_json::to_string(&tokens)
            .unwrap()
            .replace("\"", "\\\""),
    );
    context.insert("profile_grants", &{
        let mut out = Vec::new();

        for grant in profile.grants {
            out.push((
                match data.0.get_app_by_id(grant.app).await {
                    Ok(a) => a,
                    // TODO: remove grant from user (app deleted)
                    Err(_) => continue,
                },
                grant,
            ));
        }

        out
    });

    // check color contrasts
    let mut failing_color_keys: Vec<(&str, f64)> = Vec::new();
    let settings_map = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(
        &serde_json::to_string(&profile.settings).unwrap(),
    )
    .unwrap();

    if let Some(color_surface) = settings_map.get("theme_color_surface") {
        let color_surface = color_surface.as_str().unwrap();
        for setting in &settings_map {
            if !setting.0.starts_with("theme_color_text")
                | (setting.0 == "theme_color_text_primary")
                | (setting.0 == "theme_color_text_secondary")
            {
                continue;
            }

            let value = setting.1.as_str().unwrap();

            if !value.starts_with("#") {
                // we can only parse hex right now
                continue;
            }

            let c1 = Color::from(color_surface);
            let c2 = Color::from(value);
            let contrast = c1.contrast(&c2);

            if contrast < MINIMUM_CONTRAST_THRESHOLD {
                failing_color_keys.push((setting.0, contrast));
            }
        }

        context.insert("failing_color_keys", &failing_color_keys);
    } else {
        context.insert("failing_color_keys", &Vec::<&str>::new());
    }

    // return
    Ok(Html(
        data.1.render("profile/settings.html", &context).unwrap(),
    ))
}

pub fn profile_context(
    context: &mut Context,
    user: &Option<User>,
    profile: &User,
    communities: &Vec<Community>,
    is_self: bool,
    is_following: bool,
    is_following_you: bool,
    is_blocking: bool,
) {
    context.insert("profile", &profile);
    context.insert("communities", &communities);
    context.insert("is_self", &is_self);
    context.insert("is_following", &is_following);
    context.insert("is_following_you", &is_following_you);
    context.insert("is_blocking", &is_blocking);
    context.insert("warning_hash", &hash(profile.settings.warning.clone()));

    context.insert(
        "is_supporter",
        &profile.permissions.check(FinePermission::SUPPORTER),
    );

    if let Some(ua) = user {
        if !ua.settings.disable_other_themes | is_self {
            context.insert("use_user_theme", &false);
        }
    } else {
        context.insert("use_user_theme", &false);
    }
}

/// `/@{username}`
pub async fn posts_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<ProfileQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = get_user_from_token!(jar, data.0);

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    check_user_blocked_or_private!(user, other_user, data, jar);

    // check for warning
    if props.warning {
        let lang = get_lang!(jar, data.0);
        let mut context = initial_context(&data.0.0.0, lang, &user).await;

        context.insert("profile", &other_user);
        context.insert("warning_hash", &hash(other_user.settings.warning.clone()));

        return Ok(Html(
            data.1.render("profile/warning.html", &context).unwrap(),
        ));
    }

    // fetch pinned
    let ignore_users = ignore_users_gen!(user, data);
    let pinned = if props.tag.is_empty() {
        match data.0.get_pinned_posts_by_user(other_user.id).await {
            Ok(p) => match data
                .0
                .fill_posts_with_community(
                    p,
                    if let Some(ref ua) = user { ua.id } else { 0 },
                    &ignore_users,
                    &user,
                )
                .await
            {
                Ok(p) => Some(data.0.posts_muted_phrase_filter(
                    &p,
                    if let Some(ref ua) = user {
                        Some(&ua.settings.muted)
                    } else {
                        None
                    },
                )),
                Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
            },
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        }
    } else {
        None
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &user).await;

    let is_self = if let Some(ref ua) = user {
        ua.id == other_user.id
    } else {
        false
    };

    let is_following = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_following_you = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_receiver_initiator(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_blocking = if let Some(ref ua) = user {
        data.0
            .get_userblock_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    context.insert("pinned", &pinned);
    context.insert("page", &props.page);
    context.insert("tag", &props.tag);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &user,
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(data.1.render("profile/posts.html", &context).unwrap()))
}

/// `/@{username}/replies`
pub async fn replies_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<PaginatedQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = get_user_from_token!(jar, data.0);

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    check_user_blocked_or_private!(user, other_user, data, jar);

    // fetch data
    let ignore_users = crate::ignore_users_gen!(user, data);

    let posts = match data
        .0
        .get_replies_by_user(other_user.id, 12, props.page, &user)
        .await
    {
        Ok(p) => match data
            .0
            .fill_posts_with_community(
                p,
                if let Some(ref ua) = user { ua.id } else { 0 },
                &ignore_users,
                &user,
            )
            .await
        {
            Ok(p) => data.0.posts_muted_phrase_filter(
                &p,
                if let Some(ref ua) = user {
                    Some(&ua.settings.muted)
                } else {
                    None
                },
            ),
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &user).await;

    let is_self = if let Some(ref ua) = user {
        ua.id == other_user.id
    } else {
        false
    };

    let is_following = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_following_you = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_receiver_initiator(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_blocking = if let Some(ref ua) = user {
        data.0
            .get_userblock_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    context.insert("posts", &posts);
    context.insert("page", &props.page);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &user,
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(
        data.1.render("profile/replies.html", &context).unwrap(),
    ))
}

/// `/@{username}/media`
pub async fn media_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<PaginatedQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = get_user_from_token!(jar, data.0);

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    check_user_blocked_or_private!(user, other_user, data, jar);

    // fetch data
    let ignore_users = crate::ignore_users_gen!(user, data);

    let posts = match data
        .0
        .get_media_posts_by_user(other_user.id, 12, props.page, &user)
        .await
    {
        Ok(p) => match data
            .0
            .fill_posts_with_community(
                p,
                if let Some(ref ua) = user { ua.id } else { 0 },
                &ignore_users,
                &user,
            )
            .await
        {
            Ok(p) => data.0.posts_muted_phrase_filter(
                &p,
                if let Some(ref ua) = user {
                    Some(&ua.settings.muted)
                } else {
                    None
                },
            ),
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &user).await;

    let is_self = if let Some(ref ua) = user {
        ua.id == other_user.id
    } else {
        false
    };

    let is_following = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_following_you = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_receiver_initiator(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_blocking = if let Some(ref ua) = user {
        data.0
            .get_userblock_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    context.insert("posts", &posts);
    context.insert("page", &props.page);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &user,
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(data.1.render("profile/media.html", &context).unwrap()))
}

/// `/@{username}/outbox`
pub async fn outbox_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<PaginatedQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = match get_user_from_token!(jar, data.0) {
        Some(ua) => ua,
        None => {
            return Err(Html(
                render_error(Error::NotAllowed, &jar, &data, &None).await,
            ));
        }
    };

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
    };

    if user.id != other_user.id && !user.permissions.check(FinePermission::MANAGE_QUESTIONS) {
        return Err(Html(
            render_error(Error::NotAllowed, &jar, &data, &Some(user)).await,
        ));
    }

    check_user_blocked_or_private!(Some(user.clone()), other_user, data, jar);

    // fetch data
    let ignore_users = crate::ignore_users_gen!(user!, data);

    let questions = match data
        .0
        .get_questions_by_owner_paginated(other_user.id, 12, props.page)
        .await
    {
        Ok(p) => match data.0.fill_questions(p, &ignore_users).await {
            Ok(p) => p,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &Some(user.clone())).await;

    let is_self = user.id == other_user.id;

    let is_following = data
        .0
        .get_userfollow_by_initiator_receiver(user.id, other_user.id)
        .await
        .is_ok();

    let is_following_you = data
        .0
        .get_userfollow_by_receiver_initiator(user.id, other_user.id)
        .await
        .is_ok();

    let is_blocking = data
        .0
        .get_userblock_by_initiator_receiver(user.id, other_user.id)
        .await
        .is_ok();

    context.insert("questions", &questions);
    context.insert("page", &props.page);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &Some(user),
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(
        data.1.render("profile/outbox.html", &context).unwrap(),
    ))
}

/// `/@{username}/following`
pub async fn following_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<PaginatedQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = get_user_from_token!(jar, data.0);

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    check_user_blocked_or_private!(user, other_user, data, jar);

    // fetch data
    let list = match data
        .0
        .get_userfollows_by_initiator(other_user.id, 12, props.page)
        .await
    {
        Ok(l) => match data.0.fill_userfollows_with_receiver(l).await {
            Ok(l) => l,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &user).await;

    let is_self = if let Some(ref ua) = user {
        ua.id == other_user.id
    } else {
        false
    };

    let is_following = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_following_you = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_receiver_initiator(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_blocking = if let Some(ref ua) = user {
        data.0
            .get_userblock_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    context.insert("list", &list);
    context.insert("page", &props.page);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &user,
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(
        data.1.render("profile/following.html", &context).unwrap(),
    ))
}

/// `/@{username}/followers`
pub async fn followers_request(
    jar: CookieJar,
    Path(username): Path<String>,
    Query(props): Query<PaginatedQuery>,
    Extension(data): Extension<State>,
) -> impl IntoResponse {
    let data = data.read().await;
    let user = get_user_from_token!(jar, data.0);

    let other_user = match data.0.get_user_by_username(&username).await {
        Ok(ua) => ua,
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    check_user_blocked_or_private!(user, other_user, data, jar);

    // fetch data
    let list = match data
        .0
        .get_userfollows_by_receiver(other_user.id, 12, props.page)
        .await
    {
        Ok(l) => match data.0.fill_userfollows_with_initiator(l).await {
            Ok(l) => l,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    let communities = match data.0.get_memberships_by_owner(other_user.id).await {
        Ok(m) => match data.0.fill_communities(m).await {
            Ok(m) => m,
            Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
        },
        Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
    };

    // init context
    let lang = get_lang!(jar, data.0);
    let mut context = initial_context(&data.0.0.0, lang, &user).await;

    let is_self = if let Some(ref ua) = user {
        ua.id == other_user.id
    } else {
        false
    };

    let is_following = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_following_you = if let Some(ref ua) = user {
        data.0
            .get_userfollow_by_receiver_initiator(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    let is_blocking = if let Some(ref ua) = user {
        data.0
            .get_userblock_by_initiator_receiver(ua.id, other_user.id)
            .await
            .is_ok()
    } else {
        false
    };

    context.insert("list", &list);
    context.insert("page", &props.page);
    context.insert("gpa", &data.0.calculate_user_gpa(other_user.id).await);
    profile_context(
        &mut context,
        &user,
        &other_user,
        &communities,
        is_self,
        is_following,
        is_following_you,
        is_blocking,
    );

    // return
    Ok(Html(
        data.1.render("profile/followers.html", &context).unwrap(),
    ))
}