use gio::subclass::prelude::*;
use glib::{ObjectExt, ParamSpec};
use glib::{ParamFlags, ParamSpecBoolean, ParamSpecInt64, ParamSpecString, ParamSpecUInt, ToValue};
use once_cell::sync::Lazy;
use once_cell::sync::OnceCell;
use std::cell::{Cell, RefCell};
use std::str::FromStr;
use time::OffsetDateTime;
use uuid::Uuid;

use crate::Instance;

pub const UUID: &str = "uuid";
pub const NAME: &str = "name";
pub const DESCRIPTION: &str = "description";
pub const VERSION: &str = "version";
pub const INSTANCE_PATH: &str = "instance-path";
pub const LIBRARIES_PATH: &str = "libraries-path";
pub const ASSETS_PATH: &str = "assets-path";
pub const USE_FULLSCREEN: &str = "use-fullscreen";
pub const ENABLE_WINDOW_SIZE: &str = "enable-window-size";
pub const WINDOW_WIDTH: &str = "window-width";
pub const WINDOW_HEIGHT: &str = "window-height";
pub const ENABLE_MEMORY: &str = "enable-memory";
pub const MIN_MEMORY: &str = "min-memory";
pub const MAX_MEMORY: &str = "max-memory";
pub const ENABLE_JAVA_EXEC: &str = "enable-java-exec";
pub const JAVA_EXEC: &str = "java-exec";
pub const ENABLE_JVM_ARGS: &str = "enable-jvm-args";
pub const JVM_ARGS: &str = "jvm-args";
pub const CREATED: &str = "created";

mod imp {
    use super::*;

    #[derive(Debug, Default)]
    pub struct GInstance {
        pub uuid: OnceCell<String>,
        pub name: RefCell<String>,
        pub description: RefCell<String>,
        pub version: RefCell<String>,
        pub instance_path: RefCell<String>,
        pub libraries_path: RefCell<String>,
        pub assets_path: RefCell<String>,
        pub use_fullscreen: Cell<bool>,
        pub enable_window_size: Cell<bool>,
        pub window_width: Cell<u32>,
        pub window_height: Cell<u32>,
        pub enable_memory: Cell<bool>,
        pub min_memory: Cell<u32>,
        pub max_memory: Cell<u32>,
        pub enable_java_exec: Cell<bool>,
        pub java_exec: RefCell<String>,
        pub enable_jvm_args: Cell<bool>,
        pub jvm_args: RefCell<String>,
        pub created: Cell<i64>,
    }

    #[glib::object_subclass]
    impl ObjectSubclass for GInstance {
        const NAME: &'static str = "GInstance";
        type Type = super::GInstance;
        type ParentType = glib::Object;
    }

    impl ObjectImpl for GInstance {
        fn properties() -> &'static [glib::ParamSpec] {
            static PROPERTIES: Lazy<Vec<ParamSpec>> = Lazy::new(|| {
                vec![
                    ParamSpecString::new(
                        UUID,
                        "UUID",
                        "UUID",
                        Some(&Uuid::new_v4().to_string()),
                        ParamFlags::READWRITE | ParamFlags::CONSTRUCT_ONLY,
                    ),
                    ParamSpecString::new(NAME, "Name", "Name", None, ParamFlags::READWRITE),
                    ParamSpecString::new(
                        DESCRIPTION,
                        "Description",
                        "Description",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        VERSION,
                        "Version",
                        "Version",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        INSTANCE_PATH,
                        "Instance Path",
                        "Instance Path",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        LIBRARIES_PATH,
                        "Libraries Path",
                        "Libraries Path",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        ASSETS_PATH,
                        "Assets Path",
                        "Assets Path",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecBoolean::new(
                        USE_FULLSCREEN,
                        "Use Fullscreen",
                        "Use Fullscreen",
                        false,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecBoolean::new(
                        ENABLE_WINDOW_SIZE,
                        "Enable Window Size",
                        "Enable Window Size",
                        false,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecUInt::new(
                        WINDOW_WIDTH,
                        "Window Width",
                        "Window Width",
                        0,
                        u32::MAX,
                        1280,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecUInt::new(
                        WINDOW_HEIGHT,
                        "Window Height",
                        "Window Height",
                        0,
                        u32::MAX,
                        720,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecBoolean::new(
                        ENABLE_MEMORY,
                        "Enable Memory",
                        "Enable Memory",
                        false,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecUInt::new(
                        MIN_MEMORY,
                        "Min Memory",
                        "Min Memory",
                        0,
                        u32::MAX,
                        1024,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecUInt::new(
                        MAX_MEMORY,
                        "Max Memory",
                        "Max Memory",
                        0,
                        u32::MAX,
                        2048,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecBoolean::new(
                        ENABLE_JAVA_EXEC,
                        "Enable Java Exec",
                        "Enable Java Exec",
                        false,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        JAVA_EXEC,
                        "Java Exec",
                        "Java Exec",
                        Some("java"),
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecBoolean::new(
                        ENABLE_JVM_ARGS,
                        "Enable JVM Args",
                        "Enable JVM Args",
                        false,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecString::new(
                        JVM_ARGS,
                        "JVM Args",
                        "JVM Args",
                        None,
                        ParamFlags::READWRITE,
                    ),
                    ParamSpecInt64::new(
                        CREATED,
                        "Created",
                        "Created",
                        i64::MIN,
                        i64::MAX,
                        OffsetDateTime::now_utc().unix_timestamp(),
                        ParamFlags::READWRITE,
                    ),
                ]
            });

            PROPERTIES.as_ref()
        }

        fn set_property(
            &self,
            _obj: &Self::Type,
            _id: usize,
            value: &glib::Value,
            pspec: &glib::ParamSpec,
        ) {
            match pspec.name() {
                UUID => self.uuid.set(value.get().unwrap()).unwrap(),
                NAME => *self.name.borrow_mut() = value.get().unwrap(),
                DESCRIPTION => *self.description.borrow_mut() = value.get().unwrap(),
                VERSION => *self.version.borrow_mut() = value.get().unwrap(),
                INSTANCE_PATH => *self.instance_path.borrow_mut() = value.get().unwrap(),
                LIBRARIES_PATH => *self.libraries_path.borrow_mut() = value.get().unwrap(),
                ASSETS_PATH => *self.assets_path.borrow_mut() = value.get().unwrap(),
                USE_FULLSCREEN => self.use_fullscreen.set(value.get().unwrap()),
                ENABLE_WINDOW_SIZE => self.enable_window_size.set(value.get().unwrap()),
                WINDOW_WIDTH => self.window_width.set(value.get().unwrap()),
                WINDOW_HEIGHT => self.window_height.set(value.get().unwrap()),
                ENABLE_MEMORY => self.enable_memory.set(value.get().unwrap()),
                MIN_MEMORY => self.min_memory.set(value.get().unwrap()),
                MAX_MEMORY => self.max_memory.set(value.get().unwrap()),
                ENABLE_JAVA_EXEC => self.enable_java_exec.set(value.get().unwrap()),
                JAVA_EXEC => *self.java_exec.borrow_mut() = value.get().unwrap(),
                ENABLE_JVM_ARGS => self.enable_jvm_args.set(value.get().unwrap()),
                JVM_ARGS => *self.jvm_args.borrow_mut() = value.get().unwrap(),
                CREATED => self.created.set(value.get().unwrap()),
                prop => unimplemented!("Property {prop} not a member of GInstance"),
            }
        }

        fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
            match pspec.name() {
                UUID => self.uuid.get().to_value(),
                NAME => self.name.borrow().to_value(),
                DESCRIPTION => self.description.borrow().to_value(),
                VERSION => self.version.borrow().to_value(),
                INSTANCE_PATH => self.instance_path.borrow().to_value(),
                LIBRARIES_PATH => self.libraries_path.borrow().to_value(),
                ASSETS_PATH => self.assets_path.borrow().to_value(),
                USE_FULLSCREEN => self.use_fullscreen.get().to_value(),
                ENABLE_WINDOW_SIZE => self.enable_window_size.get().to_value(),
                WINDOW_WIDTH => self.window_width.get().to_value(),
                WINDOW_HEIGHT => self.window_height.get().to_value(),
                ENABLE_MEMORY => self.enable_memory.get().to_value(),
                MIN_MEMORY => self.min_memory.get().to_value(),
                MAX_MEMORY => self.max_memory.get().to_value(),
                ENABLE_JAVA_EXEC => self.enable_java_exec.get().to_value(),
                JAVA_EXEC => self.java_exec.borrow().to_value(),
                ENABLE_JVM_ARGS => self.enable_jvm_args.get().to_value(),
                JVM_ARGS => self.jvm_args.borrow().to_value(),
                CREATED => self.created.get().to_value(),
                prop => unimplemented!("Property {prop} not a member of GInstance"),
            }
        }
    }
}

glib::wrapper! {
    /// Glib object for [`Instance`](crate::instance::Instance).
    pub struct GInstance(ObjectSubclass<imp::GInstance>);
}

impl GInstance {
    /// Get [`UUID`](uuid::Uuid).
    pub fn uuid(&self) -> Uuid {
        let uuid: String = self.property(UUID);
        Uuid::from_str(&uuid).unwrap()
    }

    /// Set `name`.
    pub fn set_name(&self, value: String) {
        self.set_property(NAME, value);
    }

    /// Get `name`.
    pub fn name(&self) -> String {
        self.property(NAME)
    }

    /// Set `description`.
    pub fn set_description(&self, value: String) {
        self.set_property(DESCRIPTION, value);
    }

    /// Get `description`.
    pub fn description(&self) -> String {
        self.property(DESCRIPTION)
    }

    /// Set `version`.
    pub fn set_version(&self, value: String) {
        self.set_property(VERSION, value);
    }

    /// Get `version`.
    pub fn version(&self) -> String {
        self.property(VERSION)
    }

    /// Set `instance_path`.
    pub fn set_instance_path(&self, value: String) {
        self.set_property(INSTANCE_PATH, value);
    }

    /// Get `instance_path`.
    pub fn instance_path(&self) -> String {
        self.property(INSTANCE_PATH)
    }

    /// Set `libraries_path`.
    pub fn set_libraries_path(&self, value: String) {
        self.set_property(LIBRARIES_PATH, value);
    }

    /// Get `libraries_path`.
    pub fn libraries_path(&self) -> String {
        self.property(LIBRARIES_PATH)
    }

    /// Set `assets_path`.
    pub fn set_assets_path(&self, value: String) {
        self.set_property(ASSETS_PATH, value);
    }

    /// Get `assets_path`.
    pub fn assets_path(&self) -> String {
        self.property(ASSETS_PATH)
    }

    /// Set `use_fullscreen`.
    pub fn set_use_fullscreen(&self, value: bool) {
        self.set_property(USE_FULLSCREEN, value);
    }

    /// Get `use_fullscreen`.
    pub fn use_fullscreen(&self) -> bool {
        self.property(USE_FULLSCREEN)
    }

    /// Set `enable_window_size`.
    pub fn set_enable_window_size(&self, value: bool) {
        self.set_property(ENABLE_WINDOW_SIZE, value);
    }

    /// Get `enable_window_size`.
    pub fn enable_window_size(&self) -> bool {
        self.property(ENABLE_WINDOW_SIZE)
    }

    /// Set `window_width`.
    pub fn set_window_width(&self, value: u32) {
        self.set_property(WINDOW_WIDTH, value);
    }

    /// Get `window_width`.
    pub fn window_width(&self) -> u32 {
        self.property(WINDOW_WIDTH)
    }

    /// Set `window_height`.
    pub fn set_window_height(&self, value: u32) {
        self.set_property(WINDOW_HEIGHT, value);
    }

    /// Get `window_height`.
    pub fn window_height(&self) -> u32 {
        self.property(WINDOW_HEIGHT)
    }

    /// Set `enable_memory`.
    pub fn set_enable_memory(&self, value: bool) {
        self.set_property(ENABLE_MEMORY, value);
    }

    /// Get `enable_memory`.
    pub fn enable_memory(&self) -> bool {
        self.property(ENABLE_MEMORY)
    }

    /// Set `min_memory`.
    pub fn set_min_memory(&self, value: u32) {
        self.set_property(MIN_MEMORY, value);
    }

    /// Get `min_memory`.
    pub fn min_memory(&self) -> u32 {
        self.property(MIN_MEMORY)
    }

    /// Set `max_memory`.
    pub fn set_max_memory(&self, value: u32) {
        self.set_property(MAX_MEMORY, value);
    }

    /// Get `max_memory`.
    pub fn max_memory(&self) -> u32 {
        self.property(MAX_MEMORY)
    }

    /// Set `enable_java_exec`.
    pub fn set_enable_java_exec(&self, value: bool) {
        self.set_property(ENABLE_JAVA_EXEC, value);
    }

    /// Get `enable_java_exec`.
    pub fn enable_java_exec(&self) -> bool {
        self.property(ENABLE_JAVA_EXEC)
    }

    /// Set `java_exec`.
    pub fn set_java_exec(&self, value: String) {
        self.set_property(JAVA_EXEC, value);
    }

    /// Get `java_exec`.
    pub fn java_exec(&self) -> String {
        self.property(JAVA_EXEC)
    }

    /// Set `enable_jvm_args`.
    pub fn set_enable_jvm_args(&self, value: bool) {
        self.set_property(ENABLE_JVM_ARGS, value);
    }

    /// Get `enable_jvm_args`.
    pub fn enable_jvm_args(&self) -> bool {
        self.property(ENABLE_JVM_ARGS)
    }

    /// Set `jvm_args`.
    pub fn set_jvm_args(&self, value: String) {
        self.set_property(JVM_ARGS, value);
    }

    /// Get `jvm_args`.
    pub fn jvm_args(&self) -> String {
        self.property(JVM_ARGS)
    }

    /// Set `created`.
    pub fn set_created(&self, value: OffsetDateTime) {
        let exp = value.unix_timestamp();
        self.set_property(CREATED, exp);
    }

    /// Get `created`.
    pub fn created(&self) -> OffsetDateTime {
        let exp: i64 = self.property(CREATED);
        OffsetDateTime::from_unix_timestamp(exp).unwrap()
    }
}

impl From<Instance> for GInstance {
    fn from(instance: Instance) -> Self {
        glib::Object::new(&[
            (UUID, &instance.uuid.to_string()),
            (NAME, &instance.name),
            (DESCRIPTION, &instance.description),
            (VERSION, &instance.version),
            (INSTANCE_PATH, &instance.instance_path),
            (LIBRARIES_PATH, &instance.libraries_path),
            (ASSETS_PATH, &instance.assets_path),
            (USE_FULLSCREEN, &instance.use_fullscreen),
            (ENABLE_WINDOW_SIZE, &instance.enable_window_size),
            (WINDOW_WIDTH, &instance.window_width),
            (WINDOW_HEIGHT, &instance.window_height),
            (ENABLE_MEMORY, &instance.enable_memory),
            (MIN_MEMORY, &instance.min_memory),
            (MAX_MEMORY, &instance.max_memory),
            (ENABLE_JAVA_EXEC, &instance.enable_java_exec),
            (JAVA_EXEC, &instance.java_exec),
            (ENABLE_JVM_ARGS, &instance.enable_jvm_args),
            (JVM_ARGS, &instance.jvm_args),
            (CREATED, &instance.created.unix_timestamp()),
        ])
        .unwrap()
    }
}

impl From<GInstance> for Instance {
    fn from(ginstance: GInstance) -> Self {
        Self {
            uuid: ginstance.uuid(),
            name: ginstance.name(),
            description: ginstance.description(),
            version: ginstance.version(),
            instance_path: ginstance.instance_path(),
            libraries_path: ginstance.libraries_path(),
            assets_path: ginstance.assets_path(),
            use_fullscreen: ginstance.use_fullscreen(),
            enable_window_size: ginstance.enable_window_size(),
            window_width: ginstance.window_width(),
            window_height: ginstance.window_height(),
            enable_memory: ginstance.enable_memory(),
            min_memory: ginstance.min_memory(),
            max_memory: ginstance.max_memory(),
            enable_java_exec: ginstance.enable_java_exec(),
            java_exec: ginstance.java_exec(),
            enable_jvm_args: ginstance.enable_jvm_args(),
            jvm_args: ginstance.jvm_args(),
            created: ginstance.created(),
        }
    }
}

impl Default for GInstance {
    fn default() -> Self {
        let uuid = Uuid::new_v4();

        glib::Object::new(&[
            (UUID, &uuid.to_string()),
            (WINDOW_WIDTH, &1280_u32),
            (WINDOW_HEIGHT, &720_u32),
            (MIN_MEMORY, &1024_u32),
            (MAX_MEMORY, &2048_u32),
            (JAVA_EXEC, &"java"),
            (CREATED, &OffsetDateTime::now_utc().unix_timestamp()),
        ])
        .unwrap()
    }
}