use serde::{Serialize, Deserialize};
use libpso::character::settings;
use libpso::character::guildcard;

pub const USERFLAG_NEWCHAR: u32      = 0x00000001;
pub const USERFLAG_DRESSINGROOM: u32 = 0x00000002;

#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Default)]
pub struct UserAccountId(pub u32);
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct UserSettingsId(pub u32);
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct GuildCardDataId(pub u32);


#[derive(Clone, Debug)]
pub struct NewUserAccountEntity {
    pub email: String,
    pub username: String,
    pub password: String,
    pub guildcard: u32,
    pub team_id: Option<u32>,
    pub banned_until: Option<chrono::DateTime<chrono::Utc>>,
    pub muted_until: Option<chrono::DateTime<chrono::Utc>>,
    pub flags: u32,
    pub activated: bool
}

impl Default for NewUserAccountEntity {
    fn default() -> NewUserAccountEntity {
        NewUserAccountEntity {
            email: "".into(),
            username: "".into(),
            password: "".into(),
            guildcard: 0xFFFFFFFF,
            team_id: None,
            banned_until: None,
            muted_until: None,
            flags: 0,
            activated: false,
        }
    }
}

#[derive(Clone, Debug)]
pub struct UserAccountEntity {
    pub id: UserAccountId,
    pub username: String,
    pub password: String,
    pub guildcard: u32,
    pub team_id: Option<u32>,
    pub banned_until: Option<chrono::DateTime<chrono::Utc>>,
    pub muted_until: Option<chrono::DateTime<chrono::Utc>>,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub flags: u32, // TODO: is this used for anything other than character creation?
    pub activated: bool,
    pub at_login: bool,
    pub at_character: bool,
    pub at_ship: bool,
}

impl Default for UserAccountEntity {
    fn default() -> UserAccountEntity {
        UserAccountEntity {
            id: UserAccountId(0),
            username: "".into(),
            password: "".into(),
            guildcard: 0xFFFFFFFF,
            team_id: None,
            banned_until: None,
            muted_until: None,
            created_at: chrono::Utc::now(),
            flags: 0,
            activated: false,
            at_login: false,
            at_character: false,
            at_ship: false,
        }
    }
}

impl UserAccountEntity {
    pub fn is_currently_online(&self) -> bool {
        self.at_login | self.at_character | self.at_ship
    }
}


#[derive(Clone, Debug)]
pub struct NewUserSettingsEntity {
    pub user_id: UserAccountId,
    pub settings: settings::UserSettings,
}

impl NewUserSettingsEntity {
    pub fn new(user_id: UserAccountId) -> NewUserSettingsEntity {
        NewUserSettingsEntity {
            user_id,
            settings: settings::UserSettings::default(),
        }
    }
}

#[derive(Clone, Debug)]
pub struct UserSettingsEntity {
    pub id: UserSettingsId,
    pub user_id: UserAccountId,
    pub settings: settings::UserSettings,
}


#[derive(Clone)]
pub struct NewGuildCardDataEntity {
    pub user_id: UserAccountId,
    pub guildcard: guildcard::GuildCardData,
}

impl NewGuildCardDataEntity {
    pub fn new(user_id: UserAccountId) -> NewGuildCardDataEntity {
        NewGuildCardDataEntity {
            user_id,
            guildcard: guildcard::GuildCardData::default(),
        }
    }
}

// TODO: implement this properly
#[derive(Clone)]
pub struct GuildCardDataEntity {
    pub id: GuildCardDataId,
    pub user_id: UserAccountId,
    pub guildcard: guildcard::GuildCardData,
}

impl GuildCardDataEntity {
    pub fn new(user_id: UserAccountId) -> GuildCardDataEntity {
        GuildCardDataEntity {
            id: GuildCardDataId(0),
            user_id,
            guildcard: guildcard::GuildCardData::default(),
        }
    }
}