use crate::storage_error::StorageError;
use crate::util::db;
use crate::util::sync::{self, EntityType, Operation};
use rusqlite::{Connection, OptionalExtension, Row, Transaction, params};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SettingScope {
    User,
    Contact,
    Community,
}

impl SettingScope {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::User => "user",
            Self::Contact => "contact",
            Self::Community => "community",
        }
    }

    pub fn parse(value: &str) -> Option<Self> {
        match value {
            "user" => Some(Self::User),
            "contact" => Some(Self::Contact),
            "community" => Some(Self::Community),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SyncedSetting {
    pub id: i64,
    pub user_id: i64,
    pub scope: SettingScope,
    pub scope_key: String,
    pub name: String,
    pub payload: String,
    pub revision: i64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DeletedSetting {
    pub id: i64,
    pub revision: i64,
    pub changed: bool,
}

pub fn is_valid_name(name: &str) -> bool {
    !name.is_empty()
        && name
            .chars()
            .all(|character| character.is_alphanumeric() || "_-.".contains(character))
        && !name.contains("..")
}

fn validate_locator(scope: SettingScope, scope_key: &str, name: &str) -> Result<(), StorageError> {
    if !is_valid_name(name) {
        return Err(StorageError::Other(
            "invalid synchronized setting name".into(),
        ));
    }

    match scope {
        SettingScope::User if !scope_key.is_empty() => Err(StorageError::Other(
            "user settings must not have a target".into(),
        )),
        SettingScope::Contact => {
            let valid_contact = scope_key.parse::<i64>().is_ok_and(|id| id > 0);
            if valid_contact {
                Ok(())
            } else {
                Err(StorageError::Other("invalid contact setting target".into()))
            }
        }
        SettingScope::Community if scope_key.is_empty() => Err(StorageError::Other(
            "community settings require a target".into(),
        )),
        _ => Ok(()),
    }
}

fn normalized_scope_key(scope: SettingScope, scope_key: &str) -> Result<String, StorageError> {
    match scope {
        SettingScope::Contact => scope_key
            .parse::<i64>()
            .map(|id| id.to_string())
            .map_err(|_| StorageError::Other("invalid contact setting target".into())),
        SettingScope::User | SettingScope::Community => Ok(scope_key.to_string()),
    }
}

fn setting_from_parts(
    id: i64,
    user_id: i64,
    scope_type: String,
    scope_key: String,
    name: String,
    payload: String,
    revision: i64,
) -> Result<SyncedSetting, StorageError> {
    let scope = SettingScope::parse(&scope_type)
        .ok_or_else(|| StorageError::Other("database contains an invalid setting scope".into()))?;
    Ok(SyncedSetting {
        id,
        user_id,
        scope,
        scope_key,
        name,
        payload,
        revision,
    })
}

fn row_parts(row: &Row<'_>) -> rusqlite::Result<(i64, i64, String, String, String, String, i64)> {
    Ok((
        row.get(0)?,
        row.get(1)?,
        row.get(2)?,
        row.get(3)?,
        row.get(4)?,
        row.get(5)?,
        row.get(6)?,
    ))
}

fn load_setting_from_tx(
    tx: &Transaction<'_>,
    setting_id: i64,
) -> Result<SyncedSetting, StorageError> {
    let parts = tx.query_row(
        "SELECT id, user_id, scope_type, scope_key, name, payload, revision
         FROM synced_settings
         WHERE id = ?1 AND deleted = 0",
        [setting_id],
        row_parts,
    )?;
    setting_from_parts(
        parts.0, parts.1, parts.2, parts.3, parts.4, parts.5, parts.6,
    )
}

pub fn set(
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
    payload: &str,
) -> Result<SyncedSetting, StorageError> {
    if user_id <= 0 {
        return Err(StorageError::Other("invalid setting owner".into()));
    }
    validate_locator(scope, scope_key, name)?;
    let scope_key = normalized_scope_key(scope, scope_key)?;

    db::with_immediate_transaction(|tx| set_in_tx(tx, user_id, scope, &scope_key, name, payload))
}

fn set_in_tx(
    tx: &Transaction<'_>,
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
    payload: &str,
) -> Result<SyncedSetting, StorageError> {
    tx.execute(
        "INSERT INTO synced_settings
            (user_id, scope_type, scope_key, name, payload, revision, deleted)
         VALUES (?1, ?2, ?3, ?4, ?5, 0, 0)
         ON CONFLICT(user_id, scope_type, scope_key, name) DO NOTHING",
        params![user_id, scope.as_str(), scope_key, name, payload],
    )?;
    let setting_id: i64 = tx.query_row(
        "SELECT id FROM synced_settings
         WHERE user_id = ?1 AND scope_type = ?2 AND scope_key = ?3 AND name = ?4",
        params![user_id, scope.as_str(), scope_key, name],
        |row| row.get(0),
    )?;
    let revision = sync::record_event(
        tx,
        user_id,
        EntityType::Setting,
        setting_id,
        Operation::Upsert,
    )?;
    tx.execute(
        "UPDATE synced_settings
         SET payload = ?2, deleted = 0, revision = ?3
         WHERE id = ?1",
        params![setting_id, payload, revision],
    )?;
    load_setting_from_tx(tx, setting_id)
}

pub fn get(
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
) -> Result<Option<SyncedSetting>, StorageError> {
    if user_id <= 0 {
        return Err(StorageError::Other("invalid setting owner".into()));
    }
    validate_locator(scope, scope_key, name)?;
    let scope_key = normalized_scope_key(scope, scope_key)?;
    db::with_db(|conn| get_from_connection(conn, user_id, scope, &scope_key, name))
}

fn get_from_connection(
    conn: &Connection,
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
) -> Result<Option<SyncedSetting>, StorageError> {
    let parts = conn
        .query_row(
            "SELECT id, user_id, scope_type, scope_key, name, payload, revision
             FROM synced_settings
             WHERE user_id = ?1 AND scope_type = ?2 AND scope_key = ?3
               AND name = ?4 AND deleted = 0",
            params![user_id, scope.as_str(), scope_key, name],
            row_parts,
        )
        .optional()?;
    parts
        .map(|parts| {
            setting_from_parts(
                parts.0, parts.1, parts.2, parts.3, parts.4, parts.5, parts.6,
            )
        })
        .transpose()
}

pub fn list(user_id: i64) -> Result<Vec<SyncedSetting>, StorageError> {
    if user_id <= 0 {
        return Err(StorageError::Other("invalid setting owner".into()));
    }
    db::with_db(|conn| list_from_connection(conn, user_id))
}

fn list_from_connection(
    conn: &Connection,
    user_id: i64,
) -> Result<Vec<SyncedSetting>, StorageError> {
    let mut statement = conn.prepare(
        "SELECT id, user_id, scope_type, scope_key, name, payload, revision
         FROM synced_settings
         WHERE user_id = ?1 AND deleted = 0
         ORDER BY id ASC",
    )?;
    let rows = statement.query_map([user_id], row_parts)?;
    let mut settings = Vec::new();
    for row in rows {
        let parts = row?;
        settings.push(setting_from_parts(
            parts.0, parts.1, parts.2, parts.3, parts.4, parts.5, parts.6,
        )?);
    }
    Ok(settings)
}

pub fn list_by_ids(user_id: i64, ids: &[i64]) -> Result<Vec<SyncedSetting>, StorageError> {
    if user_id <= 0 {
        return Err(StorageError::Other("invalid setting owner".into()));
    }
    if ids.is_empty() {
        return Ok(Vec::new());
    }
    db::with_db(|conn| list_by_ids_from_connection(conn, user_id, ids))
}

fn list_by_ids_from_connection(
    conn: &Connection,
    user_id: i64,
    ids: &[i64],
) -> Result<Vec<SyncedSetting>, StorageError> {
    let placeholders = std::iter::repeat_n("?", ids.len())
        .collect::<Vec<_>>()
        .join(", ");
    let query = format!(
        "SELECT id, user_id, scope_type, scope_key, name, payload, revision
         FROM synced_settings
         WHERE user_id = ? AND deleted = 0 AND id IN ({placeholders})
         ORDER BY id ASC"
    );
    let mut values = Vec::with_capacity(ids.len() + 1);
    values.push(user_id);
    values.extend_from_slice(ids);
    let mut statement = conn.prepare(&query)?;
    let rows = statement.query_map(rusqlite::params_from_iter(values), row_parts)?;
    let mut settings = Vec::new();
    for row in rows {
        let parts = row?;
        settings.push(setting_from_parts(
            parts.0, parts.1, parts.2, parts.3, parts.4, parts.5, parts.6,
        )?);
    }
    Ok(settings)
}

pub fn delete(
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
) -> Result<Option<DeletedSetting>, StorageError> {
    if user_id <= 0 {
        return Err(StorageError::Other("invalid setting owner".into()));
    }
    validate_locator(scope, scope_key, name)?;
    let scope_key = normalized_scope_key(scope, scope_key)?;
    db::with_immediate_transaction(|tx| delete_in_tx(tx, user_id, scope, &scope_key, name))
}

fn delete_in_tx(
    tx: &Transaction<'_>,
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
    name: &str,
) -> Result<Option<DeletedSetting>, StorageError> {
    let existing = tx
        .query_row(
            "SELECT id, revision, deleted FROM synced_settings
             WHERE user_id = ?1 AND scope_type = ?2 AND scope_key = ?3 AND name = ?4",
            params![user_id, scope.as_str(), scope_key, name],
            |row| {
                Ok((
                    row.get::<_, i64>(0)?,
                    row.get::<_, i64>(1)?,
                    row.get::<_, i64>(2)?,
                ))
            },
        )
        .optional()?;
    let Some((setting_id, current_revision, deleted)) = existing else {
        return Ok(None);
    };
    if deleted != 0 {
        return Ok(Some(DeletedSetting {
            id: setting_id,
            revision: current_revision,
            changed: false,
        }));
    }

    let revision = sync::record_event(
        tx,
        user_id,
        EntityType::Setting,
        setting_id,
        Operation::Delete,
    )?;
    tx.execute(
        "UPDATE synced_settings SET deleted = 1, revision = ?2 WHERE id = ?1",
        params![setting_id, revision],
    )?;
    Ok(Some(DeletedSetting {
        id: setting_id,
        revision,
        changed: true,
    }))
}

pub(crate) fn delete_scope_in_tx(
    tx: &Transaction<'_>,
    user_id: i64,
    scope: SettingScope,
    scope_key: &str,
) -> Result<(), StorageError> {
    let setting_ids = {
        let mut statement = tx.prepare(
            "SELECT id FROM synced_settings
             WHERE user_id = ?1 AND scope_type = ?2 AND scope_key = ?3 AND deleted = 0",
        )?;
        let rows = statement.query_map(params![user_id, scope.as_str(), scope_key], |row| {
            row.get::<_, i64>(0)
        })?;
        rows.collect::<Result<Vec<_>, _>>()?
    };

    for setting_id in setting_ids {
        let revision = sync::record_event(
            tx,
            user_id,
            EntityType::Setting,
            setting_id,
            Operation::Delete,
        )?;
        tx.execute(
            "UPDATE synced_settings SET deleted = 1, revision = ?2 WHERE id = ?1",
            params![setting_id, revision],
        )?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{
        SettingScope, delete_in_tx, get_from_connection, is_valid_name,
        list_by_ids_from_connection, list_from_connection, set_in_tx,
    };
    use rusqlite::Connection;

    fn connection() -> Connection {
        let connection = Connection::open_in_memory().unwrap();
        connection
            .execute_batch(
                "
                CREATE TABLE sync_heads (
                    user_id INTEGER PRIMARY KEY,
                    version INTEGER NOT NULL
                );
                CREATE TABLE sync_events (
                    user_id INTEGER NOT NULL,
                    version INTEGER NOT NULL,
                    entity_type TEXT NOT NULL,
                    entity_id INTEGER NOT NULL,
                    operation TEXT NOT NULL,
                    created_at INTEGER NOT NULL,
                    PRIMARY KEY (user_id, version)
                );
                CREATE TABLE synced_settings (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER NOT NULL,
                    scope_type TEXT NOT NULL,
                    scope_key TEXT NOT NULL,
                    name TEXT NOT NULL,
                    payload TEXT NOT NULL,
                    revision INTEGER NOT NULL,
                    deleted INTEGER NOT NULL DEFAULT 0,
                    UNIQUE(user_id, scope_type, scope_key, name)
                );
                ",
            )
            .unwrap();
        connection
    }

    fn set(
        connection: &mut Connection,
        user_id: i64,
        scope: SettingScope,
        scope_key: &str,
        name: &str,
        payload: &str,
    ) -> super::SyncedSetting {
        let transaction = connection.transaction().unwrap();
        let setting = set_in_tx(&transaction, user_id, scope, scope_key, name, payload).unwrap();
        transaction.commit().unwrap();
        setting
    }

    #[test]
    fn parses_supported_setting_scopes() {
        assert_eq!(SettingScope::parse("user"), Some(SettingScope::User));
        assert_eq!(SettingScope::parse("contact"), Some(SettingScope::Contact));
        assert_eq!(
            SettingScope::parse("community"),
            Some(SettingScope::Community)
        );
    }

    #[test]
    fn rejects_unknown_setting_scope() {
        assert_eq!(SettingScope::parse("device"), None);
    }

    #[test]
    fn validates_setting_name_syntax() {
        assert!(is_valid_name("notifications.enabled"));
        assert!(!is_valid_name("notifications..enabled"));
        assert!(!is_valid_name(""));
        assert!(!is_valid_name("notifications/enabled"));
    }

    #[test]
    fn stores_and_loads_a_user_setting() {
        let mut connection = connection();
        let stored = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "true",
        );
        let loaded = get_from_connection(
            &connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
        )
        .unwrap();

        assert_eq!(loaded, Some(stored));
    }

    #[test]
    fn contact_and_community_targets_are_distinct() {
        let mut connection = connection();
        set(
            &mut connection,
            1,
            SettingScope::Contact,
            "123",
            "notifications.enabled",
            "false",
        );
        set(
            &mut connection,
            1,
            SettingScope::Community,
            "community-a",
            "notifications.enabled",
            "true",
        );

        assert_eq!(list_from_connection(&connection, 1).unwrap().len(), 2);
    }

    #[test]
    fn users_store_same_setting_independently() {
        let mut connection = connection();
        set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "receipts.user_read",
            "true",
        );
        set(
            &mut connection,
            2,
            SettingScope::User,
            "",
            "receipts.user_read",
            "false",
        );

        assert_eq!(
            get_from_connection(&connection, 1, SettingScope::User, "", "receipts.user_read")
                .unwrap()
                .unwrap()
                .payload,
            "true"
        );
        assert_eq!(
            get_from_connection(&connection, 2, SettingScope::User, "", "receipts.user_read")
                .unwrap()
                .unwrap()
                .payload,
            "false"
        );
    }

    #[test]
    fn update_retains_id_and_advances_revision() {
        let mut connection = connection();
        let first = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "true",
        );
        let second = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "false",
        );

        assert_eq!(second.id, first.id);
        assert!(second.revision > first.revision);
    }

    #[test]
    fn delete_tombstones_setting_and_records_delta_delete() {
        let mut connection = connection();
        let stored = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "true",
        );
        let transaction = connection.transaction().unwrap();
        let deleted = delete_in_tx(
            &transaction,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
        )
        .unwrap()
        .unwrap();
        transaction.commit().unwrap();
        let journal_operation: String = connection
            .query_row(
                "SELECT operation FROM sync_events WHERE entity_id = ?1 ORDER BY version DESC LIMIT 1",
                [stored.id],
                |row| row.get(0),
            )
            .unwrap();

        assert_eq!(deleted.id, stored.id);
        assert!(deleted.changed);
        assert_eq!(journal_operation, "delete");
        assert!(list_from_connection(&connection, 1).unwrap().is_empty());
        assert!(
            list_by_ids_from_connection(&connection, 1, &[stored.id])
                .unwrap()
                .is_empty()
        );
    }

    #[test]
    fn setting_can_be_recreated_with_the_same_id() {
        let mut connection = connection();
        let first = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "true",
        );
        let transaction = connection.transaction().unwrap();
        delete_in_tx(
            &transaction,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
        )
        .unwrap();
        transaction.commit().unwrap();
        let recreated = set(
            &mut connection,
            1,
            SettingScope::User,
            "",
            "notifications.enabled",
            "false",
        );

        assert_eq!(recreated.id, first.id);
        assert_eq!(recreated.payload, "false");
    }
}