// StarKingdoms.IO, a browser game about drifting through space
//     Copyright (C) 2023 ghostly_zsh, TerraMaster85, core
//
//     This program is free software: you can redistribute it and/or modify
//     it under the terms of the GNU Affero General Public License as published by
//     the Free Software Foundation, either version 3 of the License, or
//     (at your option) any later version.
//
//     This program is distributed in the hope that it will be useful,
//     but WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//     GNU Affero General Public License for more details.
//
//     You should have received a copy of the GNU Affero General Public License
//     along with this program.  If not, see <https://www.gnu.org/licenses/>.
use std::{collections::HashMap, net::SocketAddr};

use bevy::prelude::*;
use serde::{Deserialize, Serialize};
use starkingdoms_common::PartType as c_PartType;

#[derive(Component, Clone, Copy, Serialize, Deserialize, Debug, PartialEq)]
pub enum PlanetType {
    Earth,
    Moon,
    Mars,
}

#[derive(Component, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Debug)]
pub enum PartType {
    Placeholder,
    Hearty,
    Cargo,
    Hub,
    LandingThruster,
    LandingThrusterSuspension,
}
impl From<PartType> for c_PartType {
    fn from(value: PartType) -> Self {
        match value {
            PartType::Placeholder => c_PartType::Placeholder,
            PartType::Hearty => c_PartType::Hearty,
            PartType::Cargo => c_PartType::Cargo,
            PartType::Hub => c_PartType::Hub,
            PartType::LandingThruster => c_PartType::LandingThruster,
            PartType::LandingThrusterSuspension => c_PartType::LandingThrusterSuspension,
        }
    }
}
impl From<c_PartType> for PartType {
    fn from(value: c_PartType) -> Self {
        match value {
            c_PartType::Placeholder => PartType::Placeholder,
            c_PartType::Hearty => PartType::Hearty,
            c_PartType::Cargo => PartType::Cargo,
            c_PartType::Hub => PartType::Hub,
            c_PartType::LandingThruster => PartType::LandingThruster,
            c_PartType::LandingThrusterSuspension => PartType::LandingThrusterSuspension,
        }
    }
}

#[derive(Component, Clone, Debug)]
pub struct Attach {
    pub associated_player: Option<Entity>,
    pub parent: Option<Entity>,
    pub children: [Option<Entity>; 4],
}

#[derive(Component, Clone, Debug)]
pub struct LooseAttach {
    pub children: [Option<Entity>; 4],
}

#[derive(Component, Clone, Copy, PartialEq, Debug)]
pub struct CanAttach(pub u8); // each bit means a slot able to attach to

#[derive(Component, Clone, Copy, Serialize, Deserialize, Debug, Default)]
pub struct Input {
    pub up: bool,
    pub down: bool,
    pub left: bool,
    pub right: bool,
}

#[derive(Component, Clone, Debug)]
pub struct Player {
    pub addr: SocketAddr,
    pub username: String,
    pub input: Input,
    pub selected: Option<Entity>,
    pub save_eligibility: bool,
    pub energy_capacity: u32,
    pub energy: u32,
    pub save_amount: HashMap<PartType, u32> // PartType, amount of each module type
}

#[derive(Bundle)]
pub struct PlanetBundle {
    pub planet_type: PlanetType,
    pub transform: TransformBundle,
}

#[derive(Component, Copy, Clone)]
pub struct PartFlags {
    pub attached: bool,
}

#[derive(Bundle)]
pub struct PartBundle {
    pub transform: TransformBundle,
    pub part_type: PartType,
    pub flags: PartFlags,
}

#[derive(Bundle)]
pub struct PlayerBundle {
    pub part: PartBundle,
    pub player: Player,
    pub attach: Attach,
}

#[derive(Resource)]
pub struct ModuleTimer(pub Timer);
impl ModuleTimer {
    pub fn new() -> Self {
        Self(Timer::from_seconds(0.3, TimerMode::Repeating))
    }
}
impl Default for ModuleTimer {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Resource)]
pub struct AppKeys {
    pub app_key: Vec<u8>,
}