use std::sync::Arc;

use formatx::formatx;

use gettextrs::gettext;

use oo7::{Key, ashpd::WindowIdentifierType, dbus::ServiceError};

use serde::{Deserialize, Serialize};

use tokio::sync::OnceCell;

use zbus::zvariant::{self, ObjectPath, Optional, OwnedObjectPath, Type, Value, as_value};

use super::secret_exchange;

use crate::{

    error::custom_service_error,

    prompt::{Prompt, PromptRole},

    service::Service,

};

/// Custom serde module to handle GCR's double-Value wrapping bug

///

/// See: https://gitlab.gnome.org/GNOME/gcr/-/merge_requests/169

mod double_value_optional {

    use super::*;

                .downcast::<Value>()

        }

    }

    where

        D: serde::Deserializer<'de>,

        T: TryFrom<Value<'de>> + zvariant::Type,

        T::Error: std::fmt::Display,

    {

        }

    }

        deserializer: D,

    ) -> Result<Option<WindowIdentifierType>, D::Error>

    where

        D: serde::Deserializer<'de>,

    {

        }

    }

}

#[derive(Serialize, Deserialize, Type, Default)]

#[zvariant(signature = "dict")]

#[serde(rename_all = "kebab-case")]

// GcrPrompt properties <https://gitlab.gnome.org/GNOME/gcr/-/blob/main/gcr/gcr-prompt.c#L95>

pub struct Properties {

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    title: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    message: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    description: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    warning: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    password_new: Option<bool>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    password_strength: Option<i32>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    choice_label: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    choice_chosen: Option<bool>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize_window_id",

        skip_serializing_if = "Option::is_none",

        default

    )]

    caller_window: Option<WindowIdentifierType>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    continue_label: Option<String>,

    #[serde(

        serialize_with = "as_value::optional::serialize",

        deserialize_with = "double_value_optional::deserialize",

        skip_serializing_if = "Option::is_none",

        default

    )]

    cancel_label: Option<String>,

}

impl Properties {

        Self {

                formatx!(

                    gettext("An application wants to change the password for the “{}” keyring. Choose the new password you want to use for it."),

                    keyring,

                )

                .expect("Wrong format in translatable string"),

            ),

            password_new: Some(true),

            password_strength: None,

            choice_label: None,

            choice_chosen: None,

        }

    }

        keyring: &str,

        warning: Option<&str>,

        window_id: Option<&WindowIdentifierType>,

    ) -> Self {

        Self {

                formatx!(

                    gettext("An application wants access to the keyring '{}', but it is locked",),

                    keyring,

                )

                .expect("Wrong format in translatable string"),

            ),

            password_new: None,

            password_strength: None,

            choice_label: None,

            choice_chosen: None,

        }

    }

        Self {

                formatx!(

                    gettext("An application wants to create a new keyring called “{}”. Choose the password you want to use for it."),

                    label

                )

                .expect("Wrong format in translatable string")

            ),

            warning: None,

            password_new: Some(true),

            password_strength: None,

            choice_label: None,

            choice_chosen: None,

        }

    }

}

#[derive(Deserialize, Serialize, Debug, Type)]

#[serde(rename_all = "lowercase")]

#[zvariant(signature = "s")]

pub enum Reply {

    No,

    Yes,

}

impl zvariant::NoneValue for Reply {

    type NoneType = String;

    }

}

impl TryFrom<String> for Reply {

    type Error = String;

        }

    }

}

#[derive(Debug, Deserialize, Serialize, Type, PartialEq, Eq, PartialOrd, Ord)]

#[serde(rename_all = "lowercase")]

#[zvariant(signature = "s")]

pub enum PromptType {

    Confirm,

    Password,

}

#[zbus::proxy(

    default_service = "org.gnome.keyring.SystemPrompter",

    interface = "org.gnome.keyring.internal.Prompter",

    default_path = "/org/gnome/keyring/Prompter",

    gen_blocking = false

)]

pub trait GNOMEPrompter {

    fn begin_prompting(&self, callback: &ObjectPath<'_>) -> Result<(), ServiceError>;

    fn perform_prompt(

        &self,

        callback: &ObjectPath<'_>,

        type_: PromptType,

        properties: Properties,

        exchange: &str,

    ) -> Result<(), ServiceError>;

    fn stop_prompting(&self, callback: &ObjectPath<'_>) -> Result<(), ServiceError>;

}

#[derive(Clone)]

pub struct GNOMEPrompterCallback {

    window_id: Option<WindowIdentifierType>,

    private_key: Arc<Key>,

    public_key: Arc<Key>,

    exchange: OnceCell<String>,

    service: Service,

    prompt_path: OwnedObjectPath,

    path: OwnedObjectPath,

}

#[zbus::interface(name = "org.gnome.keyring.internal.Prompter.Callback")]

impl GNOMEPrompterCallback {

        &self,

        reply: Optional<Reply>,

        _properties: Properties,

        exchange: &str,

    ) -> Result<(), ServiceError> {

                "Prompt '{prompt_path}' does not exist."

            )));

        };

            // First PromptReady call

            }

            // Second PromptReady call with final exchange

            }

            // Dismissed prompt

            }

        };

    }

        // This is only does check if the prompt is tracked on Service

                .object_server()

        }

            .object_server()

    }

}

impl GNOMEPrompterCallback {

        window_id: Option<WindowIdentifierType>,

        service: Service,

        prompt_path: OwnedObjectPath,

    ) -> Result<Self, oo7::crypto::Error> {

        })

    }

    }

                PromptType::Password,

            ),

                PromptType::Password,

            ),

                PromptType::Password,

            ),

        };

        });

    }

                "Failed to generate AES key for SecretExchange {err}."

            ))

        })?;

                "Failed to retrieve keyring secret from SecretExchange.",

            ));

        };

        } else {

        };

        // Handle each role differently based on what validation/preparation is needed

            PromptRole::Unlock => {

                } else {

                    let properties = Properties::for_unlock(

                        Some("The unlock password was incorrect"),

                    );

                        .exchange

                        .get()

                        .expect("Exchange cannot be empty at this stage")

                        .clone();

                                PromptType::Password,

                            )

                    });

                }

            }

            PromptRole::CreateCollection => {

            }

            PromptRole::ChangePassword => {

            }

        }

    }

            .try_into_owned()

            .unwrap();

    }

}

#[cfg(test)]

mod tests {

    use std::collections::HashMap;

    use zvariant::{serialized::Context, to_bytes};

    use super::*;

    #[test]

    fn properties_serialization_roundtrip() {

        let props = Properties {

            title: Some("Test Title".to_string()),

            message: Some("Test Message".to_string()),

            ..Default::default()

        };

        // Serialize to bytes

        let ctxt = Context::new_dbus(zvariant::LE, 0);

        let encoded = to_bytes(ctxt, &props).expect("Failed to serialize");

        // Deserialize back to verify roundtrip works

        let decoded: Properties = encoded.deserialize().unwrap().0;

        assert_eq!(decoded.title, Some("Test Title".to_string()));

        assert_eq!(decoded.message, Some("Test Message".to_string()));

    }

    #[test]

    fn deserialize_properties() {

        let mut map: HashMap<String, Value> = HashMap::new();

        // Double-wrap: Value<Value<String>>

        map.insert(

            "title".to_string(),

            Value::new(Value::new("Unlock Keyring")),

        );

        map.insert(

            "message".to_string(),

            Value::new(Value::new("Authentication required")),

        );

        // Serialize the HashMap

        let ctxt = Context::new_dbus(zvariant::LE, 0);

        let encoded = to_bytes(ctxt, &map).expect("Failed to serialize test data");

        // Deserialize as Properties

        let props: Properties = encoded.deserialize().unwrap().0;

        assert_eq!(props.title, Some("Unlock Keyring".to_string()));

        assert_eq!(props.message, Some("Authentication required".to_string()));

        let mut map: HashMap<String, Value> = HashMap::new();

        // Single-wrap: Value<String> (the correct format)

        map.insert("title".to_string(), Value::new("Unlock Keyring"));

        map.insert("message".to_string(), Value::new("Authentication required"));

        // Serialize the HashMap

        let ctxt = Context::new_dbus(zvariant::LE, 0);

        let encoded = to_bytes(ctxt, &map).expect("Failed to serialize test data");

        // Deserialize as Properties - should also work

        let props: Properties = encoded.deserialize().unwrap().0;

        assert_eq!(props.title, Some("Unlock Keyring".to_string()));

        assert_eq!(props.message, Some("Authentication required".to_string()));

        let props = Properties {

            title: None,

            message: Some("Test".to_string()),

            ..Default::default()

        };

        let ctxt = Context::new_dbus(zvariant::LE, 0);

        let encoded = to_bytes(ctxt, &props).expect("Failed to serialize");

        let decoded: Properties = encoded.deserialize().unwrap().0;

        assert_eq!(decoded.title, None);

        assert_eq!(decoded.message, Some("Test".to_string()));

        let props = Properties {

            password_new: Some(true),

            password_strength: Some(42),

            choice_chosen: Some(false),

            ..Default::default()

        };

        let ctxt = Context::new_dbus(zvariant::LE, 0);

        let encoded = to_bytes(ctxt, &props).expect("Failed to serialize");

        let decoded: Properties = encoded.deserialize().unwrap().0;

        assert_eq!(decoded.password_new, Some(true));

        assert_eq!(decoded.password_strength, Some(42));

        assert_eq!(decoded.choice_chosen, Some(false));

    }

}