use rocket::serde::{Serialize, Deserialize};
use sea_orm::*;

use super::entities::{*};

#[derive(Serialize, Deserialize)]
pub struct RfidCard {
    #[serde(rename = "cardId")]
    pub card_id: String,
    #[serde(rename = "cardComment")]
    pub card_comment: String
}

// Implement `.into()` to auto map values from the database model to the local struct
impl From<rfid_cards::Model> for RfidCard {
    fn from(rfid_card: rfid_cards::Model) -> RfidCard {
        RfidCard {
            card_id: rfid_card.card_id,
            card_comment: rfid_card.card_comment,
        }
    }
}

#[derive(Serialize, Deserialize, Default)]
pub struct Member {
    pub id: i32,
    #[serde(rename = "ntnuUsername")]
    pub ntnu_username: String,
    #[serde(rename = "firstName")]
    pub first_name: String,
    #[serde(rename = "lastName")]
    pub last_name: String,
    pub email: String,
    pub balance: i32,
    #[serde(rename = "imagePreference")]
    pub image_preference: String,
    #[serde(rename = "lastName")]
    pub rfid_cards: Vec<RfidCard>
}

// Create the `.into()` functionality to auto map values from the database model to the local struct
// Don't be scared by the long model name, I typed `Members::Model` and applied the auto fix vscode suggested
impl From<members::Model> for Member {
    fn from(member: members::Model) -> Member {
        Member {
            id: member.id,
            ntnu_username: member.ntnu_username,
            first_name: member.first_name,
            last_name: member.last_name,
            email: member.email,
            balance: member.balance,
            image_preference: member.image_preference,
            rfid_cards: Vec::new(),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct MinimalMember {
    pub id: i32,
    #[serde(rename = "ntnuUsername")]
    pub ntnu_username: String,
    #[serde(rename = "firstName")]
    pub first_name: String,
    #[serde(rename = "lastName")]
    pub last_name: String,
    pub email: String,
}

// Implement DB Member Model -> MinimalMember 
impl From<members::Model> for MinimalMember {
    fn from(member: members::Model) -> MinimalMember {
        MinimalMember {
            id: member.id,
            ntnu_username: member.ntnu_username,
            first_name: member.first_name,
            last_name: member.last_name,
            email: member.email,
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct MinimalMemberWithoutId {
    #[serde(rename = "ntnuUsername")]
    pub ntnu_username: String,
    #[serde(rename = "firstName")]
    pub first_name: String,
    #[serde(rename = "lastName")]
    pub last_name: String,
    pub email: String,
}

// Create the functionality to create a database model member from the local struct model member
impl Into<members::ActiveModel> for rocket::serde::json::Json<MinimalMemberWithoutId> {
    fn into(self) -> members::ActiveModel {
        members::ActiveModel {
            ntnu_username: ActiveValue::Set(self.ntnu_username.to_owned()),
            first_name: ActiveValue::Set(self.first_name.to_owned()),
            last_name: ActiveValue::Set(self.last_name.to_owned()),
            email: ActiveValue::Set(self.email.to_owned()),
            balance: ActiveValue::Set(0),
            image_preference: ActiveValue::Set("".to_string()),
            ..Default::default()
        }
    }
}

#[derive(Serialize)]
pub struct MultipleMembersStruct {
    pub members: Vec<Member>,
}


#[derive(Deserialize, Serialize)]
pub struct Balance {
    pub balance: i32
}

#[derive(Deserialize, Serialize)]
pub struct ImagePreference {
    #[serde(rename = "imagePreference")]
    pub image_preference: String
}