use std::env;
use std::fs;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use chrono::{NaiveDate, NaiveDateTime};
use gxhash::{gxhash32, gxhash64};
use minio::s3::builders::{ObjectContent};
use minio::s3::client::ClientBuilder;
use minio::s3::creds::StaticProvider;
use minio::s3::http::BaseUrl;
use once_cell::sync::Lazy;
use rocket::{get, post, put, State};
use rocket::serde::{Deserialize, Serialize};
use crate::account::account::{generate_password, Auth, User};
use crate::dsresponse::Ds;
use crate::error::{Error, Errors};
use crate::nnid::pid_distribution::next_pid;
use crate::nnid::timezones::{OFFSET_FROM_TIMEZONE};
use crate::Pool;
use crate::xml::{Xml, YesNoVal};
use crate::email::send_verification_email;
use rand::Rng;
use mii::{get_image_png, get_image_tga};
use minio::s3::client::Client;
use minio::s3::args::PutObjectArgs;
use std::sync::Arc;

const DATABASE_ERROR: Errors = Errors{
    error: &[
        Error{
            code: "9999",
            message: "Internal server error"
        }
    ]
};

pub static S3_URL_STRING: Lazy<Box<str>> = Lazy::new(||
    env::var("S3_URL").expect("S3_URL not specified").into_boxed_str()
);

pub static S3_URL: Lazy<BaseUrl> = Lazy::new(||
    S3_URL_STRING.parse().unwrap()
);

pub static S3_USER: Lazy<Box<str>> = Lazy::new(||
    env::var("S3_USER").expect("S3_USER not specified").into_boxed_str()
);

pub static S3_PASSWD: Lazy<Box<str>> = Lazy::new(||
    env::var("S3_PASSWD").expect("S3_PASSWD not specified").into_boxed_str()
);

pub static S3_BUCKET: Lazy<Box<str>> = Lazy::new(||
    env::var("S3_BUCKET").expect("S3_BUCKET not specified").into_boxed_str()
);

fn get_mii_img_url_path(pid: i32, format: &str) -> String{
    format!("mii/{}/main.{}", pid, format)
}

fn get_mii_img_url(pid: i32, format: &str) -> String{
    format!("{}/pn-boss/{}", &*S3_URL_STRING, get_mii_img_url_path(pid, format))
}

pub async fn generate_s3_images(pid: i32, mii_data: &str) {
    let auth = StaticProvider::new(&S3_USER, &S3_PASSWD, None);

    let Ok(client) = ClientBuilder::new(S3_URL.clone())
        .provider(Some(Box::new(auth)))
        .build()
    else {
        println!("Failed to build S3 client for PID {}", pid);
        return;
    };

    let Some(image) = mii::get_image_png(mii_data).await else {
        println!("Failed to fetch PNG image for PID {}", pid);
        return;
    };

    let object_name = get_mii_img_url_path(pid, "png");
    let object_content = ObjectContent::from(image);

    if let Err(e) = client.put_object_content(&**S3_BUCKET, &object_name, object_content).send().await {
        println!("Failed to upload PNG for PID {}: {:?}", pid, e);
    } else {
        println!("Successfully uploaded PNG for PID {}", pid);
    }

    let Some(image) = mii::get_image_tga(mii_data).await else {
        println!("Failed to fetch TGA image for PID {}", pid);
        return;
    };

    let object_name = get_mii_img_url_path(pid, "tga");
    let object_content = ObjectContent::from(image);

    if let Err(e) = client.put_object_content(&**S3_BUCKET, &object_name, object_content).send().await {
        println!("Failed to upload TGA for PID {}: {:?}", pid, e);
    } else {
        println!("Successfully uploaded TGA for PID {}", pid);
    }
}

#[derive(Deserialize)]
pub struct Email{
    address: Box<str>
}

pub struct S3ClientState {
    pub client: Arc<Client>,
}

#[derive(Deserialize)]
pub struct UpdateMiiData {
    name: Box<str>,
    primary: crate::xml::YesNoVal,
    data: Box<str>,
}

#[derive(Deserialize, Serialize)]
pub struct Mii{
    name: Box<str>,
    primary: YesNoVal,
    data: Box<str>,
}

#[derive(Deserialize)]
#[serde(rename(serialize = "person"))]
pub struct AccountCreationData{
    birth_date: NaiveDate,
    user_id: Box<str>,
    password: Box<str>,
    country: Box<str>,
    language: Box<str>,
    tz_name: Box<str>,
    email: Email,
    mii: Mii,
    gender: Box<str>,
    marketing_flag: YesNoVal,
    off_device_flag: YesNoVal,
    region: i32
}

#[derive(Serialize)]
#[serde(rename(serialize = "person"))]
pub struct AccountCreationResponseData{
    pid: i32
}

#[post("/v1/api/people", data="<data>")]
pub async fn create_account(database: &State<Pool>, data: Xml<AccountCreationData>) -> Result<Xml<AccountCreationResponseData>, Option<Errors>>{
    let database = database.inner();

    // its fine to crash here if we cant get the next pid as that is in my opinion a dead state
    // anyways as noone can register anymore, EVER

    let pid = next_pid(database).await;

    let verification_code: i32 = rand::thread_rng().gen_range(100_000..1_000_000);

    let AccountCreationData {
        user_id,
        password,
        birth_date,
        tz_name,
        language,
        email: Email{
            address
        },
        mii: Mii{
            name,
            data,
            ..
        },
        marketing_flag,
        gender,
        region,
        country,
        off_device_flag,
        ..
    } = data.0;


    let password = generate_password(pid, &password).ok_or(None)?;

    sqlx::query!("
        INSERT INTO users (
                                 pid,
                                 username,
                                 password,
                                 birthdate,
                                 timezone,
                                 email,
                                 country,
                                 language,
                                 marketing_allowed,
                                 off_device_allowed,
                                 region,
                                 gender,
                                 mii_data,
                                 verification_code
                                 ) VALUES (
                                            $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14
                                 )
    ",
        pid,
        user_id.as_ref(),
        password,
        birth_date,
        tz_name.as_ref(),
        address.as_ref(),
        country.as_ref(),
        language.as_ref(),
        marketing_flag.0,
        off_device_flag.0,
        region,
        gender.as_ref(),
        data.as_ref(),
        verification_code,
    ).execute(database).await.unwrap();

    generate_s3_images(pid, &data).await;

    if let Err(e) = send_verification_email(address.as_ref(), verification_code, user_id.as_ref()).await {
        println!("Failed to send verification email: {e}");
    }

    Ok(
        Xml(AccountCreationResponseData{
            pid
        })
    )
}

// #[derive(Serialize)]
// struct DevAttr{
//
// }

#[derive(Serialize)]
struct EmailInfoOwnProfileData{
    address: String,
    id: u32,
    parent: YesNoVal,
    primary: YesNoVal,
    reachable: YesNoVal,
    #[serde(rename = "type")]
    email_type: String,
    updated_by: String,
    validated: YesNoVal,
    validated_date: Option<NaiveDateTime>
}

#[derive(Serialize)]
struct MiiImage{
    cached_url: String,
    id: u32,
    url: String,
    #[serde(rename = "type")]
    image_type: String
}


#[derive(Serialize)]
struct MiiImages{
    mii_image: MiiImage
}

#[derive(Serialize)]
struct MiiDataOwnProfileData{
    status: String,
    data: String,
    id: u32,
    mii_hash: String,
    mii_images: MiiImages,
    name: String,
    primary: YesNoVal
}



#[derive(Serialize)]
#[serde(rename(serialize = "person"))]
pub struct GetOwnProfileData{
    active_flag: YesNoVal,
    birth_date: NaiveDate,
    country: String,
    create_date: NaiveDateTime,
    gender: String,
    language: String,
    updated: NaiveDateTime,
    marketing_flag: YesNoVal,
    off_device_flag: YesNoVal,
    pid: i32,
    email: EmailInfoOwnProfileData,
    mii: MiiDataOwnProfileData,
    region: i32,
    tz_name: String,
    user_id: String,
    utc_offset: String
}

#[get("/v1/api/people/@me/profile")]
pub fn get_own_profile(user: Auth<false>) -> Ds<Xml<GetOwnProfileData>>{
    build_own_profile(user.into())
}

#[get("/v1/api/people/@me/devices/owner")]
pub fn get_device_owner(user: Auth<false>) -> Ds<Xml<GetOwnProfileData>>{
    build_own_profile(user.into())
}

#[post("/v1/api/people/@me/devices")]
pub fn get_own_device(user: Auth<false>) -> Ds<Xml<GetOwnProfileData>>{
    build_own_profile(user.into())
}

fn build_own_profile(user: User) -> Ds<Xml<GetOwnProfileData>> {
    let User {
        username,
        pid,
        // account_level,
        mii_data,
        gender,
        birthdate,
        country,
        creation_date,
        timezone,
        language,
        email,
        email_verified_since,
        updated,
        marketing_allowed,
        off_device_allowed,
        region,
        // verification_code,
        ..
    } = user.into();

    let timezone_offset = (&*OFFSET_FROM_TIMEZONE).get(&timezone).unwrap().to_owned();

    let mii_data = mii_data
        .replace("\n", "")
        .replace("\t", "")
        .replace("\r", "")
        .replace(" ", "");

    Ds(Xml(
        GetOwnProfileData {
            active_flag: YesNoVal(true),
            pid,
            user_id: username,
            gender,
            birth_date: birthdate,
            country,
            create_date: creation_date,
            tz_name: timezone,
            language,
            updated,
            marketing_flag: YesNoVal(marketing_allowed),
            email: EmailInfoOwnProfileData {
                id: gxhash32(email.as_bytes(), 0),
                address: email,
                validated: YesNoVal(email_verified_since.is_some()),
                validated_date: email_verified_since,
                email_type: "DEFAULT".to_string(),
                updated_by: "USER".to_string(),
                reachable: YesNoVal(true),
                primary: YesNoVal(true),
                parent: YesNoVal(false),
            },
            mii: MiiDataOwnProfileData {
                id: gxhash32(mii_data.as_bytes(), 0),
                mii_hash: hex::encode(bytemuck::bytes_of(
                    &(gxhash64(mii_data.as_bytes(), 1) & !(0x1000000000000000))
                )),
                name: mii::MiiData::read(&mii_data)
                .map(|v| v.name)
                .unwrap_or_else(|| "INVALID".to_string()),
                primary: YesNoVal(true),
                data: mii_data,
                status: "COMPLETED".to_string(),
                mii_images: MiiImages {
                    mii_image: {
                        let image_url = get_mii_img_url(pid, "tga");
                        let url_hash = gxhash32(image_url.as_bytes(), 0);
                        MiiImage {
                            image_type: "standard".to_string(),
                            id: url_hash,
                            url: image_url.clone(),
                            cached_url: image_url,
                        }
                    }
                }
            },
            off_device_flag: YesNoVal(off_device_allowed),
            region,
            utc_offset: timezone_offset,
        }
    ))
}

#[put("/v1/api/people/@me/miis/@primary", data = "<data>")]
pub async fn change_mii(
    database: &State<Pool>,
    s3: &State<S3ClientState>,
    auth: Auth<false>,
    data: Xml<UpdateMiiData>,
) -> Result<(), Option<Errors<'static>>> {
    let db = database.inner();
    let pid = auth.pid;
    let mii_data = data.data.as_ref();

    println!("Received new Mii data update for PID {}", pid);

    let result = sqlx::query!(
        "UPDATE users SET mii_data = $1 WHERE pid = $2",
        mii_data,
        pid
    )
        .execute(db)
        .await;

    if let Err(e) = result {
        println!("Failed to update Mii data for PID {}: {:?}", pid, e);
        return Err(Some(DATABASE_ERROR));
    }

    println!("Successfully updated Mii data for PID {}", pid);

    generate_mii_images(s3.client.clone(), &**S3_BUCKET, pid, mii_data).await;

    Ok(())
}

pub async fn generate_mii_images(client: Arc<Client>, bucket: &str, pid: i32, mii_data: &str) {
    let user_mii_key = format!("mii/{}", pid);

    async fn save_and_upload(
        client: &Client,
        bucket: &str,
        key: &str,
        data: &[u8],
    ) -> Result<(), Box<dyn std::error::Error>> {
        let temp_path = format!("/tmp/{}", key.replace("/", "_"));

        {
            let mut file = std::fs::File::create(&temp_path)?;
            file.write_all(data)?;
            file.flush()?;
        }

        let content = ObjectContent::from(std::path::Path::new(&temp_path));
        client.put_object_content(bucket, key, content).send().await?;

        std::fs::remove_file(&temp_path)?;

        Ok(())
    }

    if let Some(png_data) = get_image_png(mii_data).await {
        if let Err(e) = save_and_upload(&client, bucket, &format!("{}/normal_face.png", user_mii_key), &png_data).await {
            println!("Failed to upload normal_face.png for PID {}: {:?}", pid, e);
        }
    }

    if let Some(tga_data) = get_image_tga(mii_data).await {
        if let Err(e) = save_and_upload(&client, bucket, &format!("{}/standard.tga", user_mii_key), &tga_data).await {
            println!("Failed to upload standard.tga for PID {}: {:?}", pid, e);
        }
    }

    let expressions = [
        "frustrated",
        "smile_open_mouth",
        "wink_left",
        "sorrow",
        "surprise_open_mouth",
    ];

    for expression in expressions.iter() {
        let url = format!(
            "https://mii-unsecure.ariankordi.net/miis/image.png?data={}&expression={}&type=face&width=128&instance_count=1",
            mii_data, expression
        );

        if let Ok(resp) = reqwest::get(&url).await {
            if let Ok(bytes) = resp.bytes().await {
                if let Err(e) = save_and_upload(&client, bucket, &format!("{}/{}.png", user_mii_key, expression), &bytes).await {
                    println!("Failed to upload {}.png for PID {}: {:?}", expression, pid, e);
                }
            }
        }
    }

    let body_url = format!(
        "https://mii-unsecure.ariankordi.net/miis/image.png?data={}&type=all_body&width=270&instance_count=1",
        mii_data
    );

    if let Ok(resp) = reqwest::get(&body_url).await {
        if let Ok(bytes) = resp.bytes().await {
            if let Err(e) = save_and_upload(&client, bucket, &format!("{}/body.png", user_mii_key), &bytes).await {
                println!("Failed to upload body.png for PID {}: {:?}", pid, e);
            }
        }
    }

    println!("Finished Mii image generation for PID {}", pid);
}