#![allow(clippy::type_complexity)]
use std::marker::PhantomData;
use std::path::Path;
use std::{fmt, io, ops::Not as _, str::FromStr, time};

use sqlite as sql;
use thiserror::Error;

use crate::node::{Alias, AliasStore};
use crate::prelude::{Id, NodeId};

use super::{Node, Policy, Repo, Scope};

/// How long to wait for the database lock to be released before failing a read.
const DB_READ_TIMEOUT: time::Duration = time::Duration::from_secs(3);
/// How long to wait for the database lock to be released before failing a write.
const DB_WRITE_TIMEOUT: time::Duration = time::Duration::from_secs(6);

#[derive(Error, Debug)]
pub enum Error {
    /// I/O error.
    #[error("i/o error: {0}")]
    Io(#[from] io::Error),
    /// An Internal error.
    #[error("internal error: {0}")]
    Internal(#[from] sql::Error),
}

/// Read-only type witness.
pub struct Read;
/// Read-write type witness.
pub struct Write;

/// Read only config.
pub type ConfigReader = Config<Read>;
/// Read-write config.
pub type ConfigWriter = Config<Write>;

/// Tracking configuration.
pub struct Config<T> {
    db: sql::Connection,
    _marker: PhantomData<T>,
}

impl<T> fmt::Debug for Config<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Config(..)")
    }
}

impl Config<Read> {
    const SCHEMA: &'static str = include_str!("schema.sql");

    /// Same as [`Self::open`], but in read-only mode. This is useful to have multiple
    /// open databases, as no locking is required.
    pub fn reader<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
        let mut db =
            sql::Connection::open_with_flags(path, sqlite::OpenFlags::new().with_read_only())?;
        db.set_busy_timeout(DB_READ_TIMEOUT.as_millis() as usize)?;
        db.execute(Self::SCHEMA)?;

        Ok(Self {
            db,
            _marker: PhantomData,
        })
    }

    /// Create a new in-memory address book.
    pub fn memory() -> Result<Self, Error> {
        let db = sql::Connection::open_with_flags(
            ":memory:",
            sqlite::OpenFlags::new().with_read_only(),
        )?;
        db.execute(Self::SCHEMA)?;

        Ok(Self {
            db,
            _marker: PhantomData,
        })
    }
}

impl Config<Write> {
    const SCHEMA: &'static str = include_str!("schema.sql");

    /// Open a policy store at the given path. Creates a new store if it
    /// doesn't exist.
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
        let mut db = sql::Connection::open(path)?;
        db.set_busy_timeout(DB_WRITE_TIMEOUT.as_millis() as usize)?;
        db.execute(Self::SCHEMA)?;

        Ok(Self {
            db,
            _marker: PhantomData,
        })
    }

    /// Create a new in-memory address book.
    pub fn memory() -> Result<Self, Error> {
        let db = sql::Connection::open(":memory:")?;
        db.execute(Self::SCHEMA)?;

        Ok(Self {
            db,
            _marker: PhantomData,
        })
    }

    /// Get a read-only version of this store.
    pub fn read_only(self) -> ConfigReader {
        Config {
            db: self.db,
            _marker: PhantomData,
        }
    }

    /// Track a node.
    pub fn track_node(&mut self, id: &NodeId, alias: Option<&str>) -> Result<bool, Error> {
        let mut stmt = self.db.prepare(
            "INSERT INTO `following` (id, alias)
             VALUES (?1, ?2)
             ON CONFLICT DO UPDATE
             SET alias = ?2 WHERE alias != ?2",
        )?;

        stmt.bind((1, id))?;
        stmt.bind((2, alias.unwrap_or_default()))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }

    /// Track a repository.
    pub fn track_repo(&mut self, id: &Id, scope: Scope) -> Result<bool, Error> {
        let mut stmt = self.db.prepare(
            "INSERT INTO `seeding` (id, scope)
             VALUES (?1, ?2)
             ON CONFLICT DO UPDATE
             SET scope = ?2 WHERE scope != ?2",
        )?;

        stmt.bind((1, id))?;
        stmt.bind((2, scope))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }

    /// Set a node's tracking policy.
    pub fn set_node_policy(&mut self, id: &NodeId, policy: Policy) -> Result<bool, Error> {
        let mut stmt = self.db.prepare(
            "INSERT INTO `following` (id, policy)
             VALUES (?1, ?2)
             ON CONFLICT DO UPDATE
             SET policy = ?2 WHERE policy != ?2",
        )?;

        stmt.bind((1, id))?;
        stmt.bind((2, policy))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }

    /// Set a repository's tracking policy.
    pub fn set_repo_policy(&mut self, id: &Id, policy: Policy) -> Result<bool, Error> {
        let mut stmt = self.db.prepare(
            "INSERT INTO `seeding` (id, policy)
             VALUES (?1, ?2)
             ON CONFLICT DO UPDATE
             SET policy = ?2 WHERE policy != ?2",
        )?;

        stmt.bind((1, id))?;
        stmt.bind((2, policy))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }

    /// Untrack a node.
    pub fn untrack_node(&mut self, id: &NodeId) -> Result<bool, Error> {
        let mut stmt = self.db.prepare("DELETE FROM `following` WHERE id = ?")?;

        stmt.bind((1, id))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }

    /// Untrack a repository.
    pub fn untrack_repo(&mut self, id: &Id) -> Result<bool, Error> {
        let mut stmt = self.db.prepare("DELETE FROM `seeding` WHERE id = ?")?;

        stmt.bind((1, id))?;
        stmt.next()?;

        Ok(self.db.change_count() > 0)
    }
}

/// `Read` methods for `Config`. This implies that a
/// `Config<Write>` can access these functions as well.
impl<T> Config<T> {
    /// Check if a node is tracked.
    pub fn is_node_tracked(&self, id: &NodeId) -> Result<bool, Error> {
        Ok(matches!(
            self.node_policy(id)?,
            Some(Node {
                policy: Policy::Allow,
                ..
            })
        ))
    }

    /// Check if a repository is tracked.
    pub fn is_repo_tracked(&self, id: &Id) -> Result<bool, Error> {
        Ok(matches!(
            self.repo_policy(id)?,
            Some(Repo {
                policy: Policy::Allow,
                ..
            })
        ))
    }

    /// Get a node's tracking policy.
    pub fn node_policy(&self, id: &NodeId) -> Result<Option<Node>, Error> {
        let mut stmt = self
            .db
            .prepare("SELECT alias, policy FROM `following` WHERE id = ?")?;

        stmt.bind((1, id))?;

        if let Some(Ok(row)) = stmt.into_iter().next() {
            let alias = row.read::<&str, _>("alias");
            let alias = alias
                .is_empty()
                .not()
                .then_some(alias.to_owned())
                .and_then(|s| Alias::from_str(&s).ok());
            let policy = row.read::<Policy, _>("policy");

            return Ok(Some(Node {
                id: *id,
                alias,
                policy,
            }));
        }
        Ok(None)
    }

    /// Get a repository's tracking policy.
    pub fn repo_policy(&self, id: &Id) -> Result<Option<Repo>, Error> {
        let mut stmt = self
            .db
            .prepare("SELECT scope, policy FROM `seeding` WHERE id = ?")?;

        stmt.bind((1, id))?;

        if let Some(Ok(row)) = stmt.into_iter().next() {
            return Ok(Some(Repo {
                id: *id,
                scope: row.read::<Scope, _>("scope"),
                policy: row.read::<Policy, _>("policy"),
            }));
        }
        Ok(None)
    }

    /// Get node tracking policies.
    pub fn node_policies(&self) -> Result<Box<dyn Iterator<Item = Node>>, Error> {
        let mut stmt = self
            .db
            .prepare("SELECT id, alias, policy FROM `following`")?
            .into_iter();
        let mut entries = Vec::new();

        while let Some(Ok(row)) = stmt.next() {
            let id = row.read("id");
            let alias = row.read::<&str, _>("alias").to_owned();
            let alias = alias
                .is_empty()
                .not()
                .then_some(alias.to_owned())
                .and_then(|s| Alias::from_str(&s).ok());
            let policy = row.read::<Policy, _>("policy");

            entries.push(Node { id, alias, policy });
        }
        Ok(Box::new(entries.into_iter()))
    }

    // TODO: see if sql can return iterator directly
    /// Get repository tracking policies.
    pub fn repo_policies(&self) -> Result<Box<dyn Iterator<Item = Repo>>, Error> {
        let mut stmt = self
            .db
            .prepare("SELECT id, scope, policy FROM `seeding`")?
            .into_iter();
        let mut entries = Vec::new();

        while let Some(Ok(row)) = stmt.next() {
            let id = row.read("id");
            let scope = row.read("scope");
            let policy = row.read::<Policy, _>("policy");

            entries.push(Repo { id, scope, policy });
        }
        Ok(Box::new(entries.into_iter()))
    }
}

impl<T> AliasStore for Config<T> {
    /// Retrieve `alias` of given node.
    /// Calls `Self::node_policy` under the hood.
    fn alias(&self, nid: &NodeId) -> Option<Alias> {
        self.node_policy(nid)
            .map(|node| node.and_then(|n| n.alias))
            .unwrap_or(None)
    }
}

#[cfg(test)]
mod test {
    use crate::assert_matches;

    use super::*;
    use crate::test::arbitrary;

    #[test]
    fn test_track_and_untrack_node() {
        let id = arbitrary::gen::<NodeId>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_node(&id, Some("eve")).unwrap());
        assert!(db.is_node_tracked(&id).unwrap());
        assert!(!db.track_node(&id, Some("eve")).unwrap());
        assert!(db.untrack_node(&id).unwrap());
        assert!(!db.is_node_tracked(&id).unwrap());
    }

    #[test]
    fn test_track_and_untrack_repo() {
        let id = arbitrary::gen::<Id>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_repo(&id, Scope::All).unwrap());
        assert!(db.is_repo_tracked(&id).unwrap());
        assert!(!db.track_repo(&id, Scope::All).unwrap());
        assert!(db.untrack_repo(&id).unwrap());
        assert!(!db.is_repo_tracked(&id).unwrap());
    }

    #[test]
    fn test_node_policies() {
        let ids = arbitrary::vec::<NodeId>(3);
        let mut db = Config::open(":memory:").unwrap();

        for id in &ids {
            assert!(db.track_node(id, None).unwrap());
        }
        let mut entries = db.node_policies().unwrap();
        assert_matches!(entries.next(), Some(Node { id, .. }) if id == ids[0]);
        assert_matches!(entries.next(), Some(Node { id, .. }) if id == ids[1]);
        assert_matches!(entries.next(), Some(Node { id, .. }) if id == ids[2]);
    }

    #[test]
    fn test_repo_policies() {
        let ids = arbitrary::vec::<Id>(3);
        let mut db = Config::open(":memory:").unwrap();

        for id in &ids {
            assert!(db.track_repo(id, Scope::All).unwrap());
        }
        let mut entries = db.repo_policies().unwrap();
        assert_matches!(entries.next(), Some(Repo { id, .. }) if id == ids[0]);
        assert_matches!(entries.next(), Some(Repo { id, .. }) if id == ids[1]);
        assert_matches!(entries.next(), Some(Repo { id, .. }) if id == ids[2]);
    }

    #[test]
    fn test_update_alias() {
        let id = arbitrary::gen::<NodeId>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_node(&id, Some("eve")).unwrap());
        assert_eq!(
            db.node_policy(&id).unwrap().unwrap().alias,
            Some(Alias::from_str("eve").unwrap())
        );
        assert!(db.track_node(&id, None).unwrap());
        assert_eq!(db.node_policy(&id).unwrap().unwrap().alias, None);
        assert!(!db.track_node(&id, None).unwrap());
        assert!(db.track_node(&id, Some("alice")).unwrap());
        assert_eq!(
            db.node_policy(&id).unwrap().unwrap().alias,
            Some(Alias::new("alice"))
        );
    }

    #[test]
    fn test_update_scope() {
        let id = arbitrary::gen::<Id>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_repo(&id, Scope::All).unwrap());
        assert_eq!(db.repo_policy(&id).unwrap().unwrap().scope, Scope::All);
        assert!(db.track_repo(&id, Scope::Followed).unwrap());
        assert_eq!(db.repo_policy(&id).unwrap().unwrap().scope, Scope::Followed);
    }

    #[test]
    fn test_repo_policy() {
        let id = arbitrary::gen::<Id>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_repo(&id, Scope::All).unwrap());
        assert_eq!(db.repo_policy(&id).unwrap().unwrap().policy, Policy::Allow);
        assert!(db.set_repo_policy(&id, Policy::Block).unwrap());
        assert_eq!(db.repo_policy(&id).unwrap().unwrap().policy, Policy::Block);
    }

    #[test]
    fn test_node_policy() {
        let id = arbitrary::gen::<NodeId>(1);
        let mut db = Config::open(":memory:").unwrap();

        assert!(db.track_node(&id, None).unwrap());
        assert_eq!(db.node_policy(&id).unwrap().unwrap().policy, Policy::Allow);
        assert!(db.set_node_policy(&id, Policy::Block).unwrap());
        assert_eq!(db.node_policy(&id).unwrap().unwrap().policy, Policy::Block);
    }
}