// Copyright (c) 2017 repomon-config developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.

//! Configuration management for repomon.
//!
//! # Examples
//!
//! ## Read from TOML string
//!
//! ```
//! # use repomon_config::error::Result;
//! # use repomon_config::{read_toml, Branches};
//! # use std::io::Cursor;
//! #
//! # fn read() -> Result<()> {
//!     let test_toml = r#"[[branch.blah]]
//!     name = "origin/master"
//!     interval = "1m"
//!
//!     [[branch.repomon]]
//!     name = "origin/master"
//!     interval = "1m"
//!
//!     [[branch.repomon]]
//!     name = "origin/feature/testing"
//!     interval = "1m"
//!
//!     [[branch.repomon-config]]
//!     name = "origin/master"
//!     interval = "1m"
//!     "#;
//!
//!     // Serialize the TOML above into a `Branches` struct.
//!     let mut reader = Cursor::new(test_toml);
//!     let branches = read_toml(&mut reader)?;
//!
//!     // Check the `Branches` struct.
//!     let branch_map = branches.branch_map();
//!     assert_eq!(branch_map.keys().len(), 3);
//!     assert!(branch_map.contains_key("repomon"));
//!     assert!(branch_map.contains_key("repomon-config"));
//!     assert!(branch_map.contains_key("blah"));
//!
//!     // Check we have the right number of branch definitions per repo.
//!     let mut branches = branch_map.get("repomon").ok_or("invalid key")?;
//!     assert_eq!(branches.len(), 2);
//!     branches = branch_map.get("repomon-config").ok_or("invalid key")?;
//!     assert_eq!(branches.len(), 1);
//!     branches = branch_map.get("blah").ok_or("invalid key")?;
//!     assert_eq!(branches.len(), 1);
//! #   Ok(())
//! # }
//! ```
//!
//! ## Write to TOML string
//!
//! ```
//! # use repomon_config::error::Result;
//! # use repomon_config::{write_toml, Branch, Branches};
//! # use std::collections::BTreeMap;
//! # use std::io::{Cursor, Write};
//! #
//! # const TEST_TOML: &str = r#"[[branch.blah]]
//! # name = "origin/master"
//! # interval = "1m"
//! #
//! # [[branch.repomon]]
//! # name = "origin/master"
//! # interval = "1m"
//! #
//! # [[branch.repomon]]
//! # name = "origin/feature/testing"
//! # interval = "1m"
//! #
//! # [[branch.repomon-config]]
//! # name = "origin/master"
//! # interval = "1m"
//! # "#;
//! #
//! # fn write() -> Result<()> {
//!       // Setup the `Branches` struct.
//!       let mut master: Branch = Default::default();
//!       master.set_name("origin/master".to_string());
//!       master.set_interval("1m".to_string());
//!
//!       let mut feature_testing: Branch = Default::default();
//!       feature_testing.set_name("origin/feature/testing".to_string());
//!       feature_testing.set_interval("1m".to_string());
//!
//!       let repomon_branches = vec![master.clone(), feature_testing];
//!       let blah_branches = vec![master.clone()];
//!       let repomon_config_branches = vec![master];
//!
//!       let mut branch_map = BTreeMap::new();
//!       branch_map.insert("repomon".to_string(), repomon_branches);
//!       branch_map.insert("repomon-config".to_string(), repomon_config_branches);
//!       branch_map.insert("blah".to_string(), blah_branches);
//!
//!       let mut branches: Branches = Default::default();
//!       branches.set_branch_map(branch_map);
//!
//!       // Write the TOML to the given buf.
//!       let mut buf = [0; 5000];
//!
//!       // Wrapped to drop mutable borrow.
//!       {
//!         let mut writer = Cursor::new(&mut buf[..]);
//!         write_toml(&branches, &mut writer)?;
//!       }
//!
//!       // Check that the result is the same as the TOML above.
//!       assert_eq!(TEST_TOML, String::from_utf8_lossy(&buf));
//! #   Ok(())
//! # }
//! ```
//!
#[macro_use]
extern crate error_chain;
#[macro_use]
extern crate getset;
#[macro_use]
extern crate serde_derive;

extern crate toml;

use error::Result;
use std::collections::BTreeMap;
use std::io::{Read, Write};

pub mod error;

/// A map of repo name to branch definitions.
#[derive(Clone, Debug, Default, Deserialize, Getters, Serialize, Setters)]
pub struct Branches {
    /// A map of repo name to a vector branches to monitor.
    #[get = "pub"]
    #[set = "pub"]
    #[serde(rename = "branch")]
    branch_map: BTreeMap<String, Vec<Branch>>,
}

/// A branch to monitor for changes.
#[derive(Clone, Debug, Default, Deserialize, Getters, Serialize, Setters)]
pub struct Branch {
    /// The fully qualified branch name, e.g. `origin/master` for the remote
    /// or `master` for the local.
    #[get = "pub"]
    #[set = "pub"]
    name: String,
    /// The interval to check the branch for changes.
    #[get = "pub"]
    #[set = "pub"]
    interval: String,
}

/// Read TOML from the given `reader` and deserialize into a `Repos` struct.
pub fn read_toml<R>(reader: &mut R) -> Result<Branches>
where
    R: Read,
{
    let mut toml_str = String::new();
    let bytes_read = reader.read_to_string(&mut toml_str)?;

    if bytes_read > 0 {
        Ok(toml::from_str(&toml_str)?)
    } else {
        Err("Unable to read any bytes from the reader".into())
    }
}

/// Write TOML serialized from the `repos` struct to the given writer.
pub fn write_toml<W>(repos: &Branches, writer: &mut W) -> Result<()>
where
    W: Write,
{
    let toml = toml::to_string(&repos)?;
    Ok(writer.write_all(toml.as_bytes())?)
}

#[cfg(test)]
mod tests {
    use super::{Branch, Branches};
    use std::collections::BTreeMap;
    use std::io::Cursor;
    use toml;

    const TEST_TOML: &str = r#"[[branch.blah]]
name = "origin/master"
interval = "1m"

[[branch.repomon]]
name = "origin/master"
interval = "1m"

[[branch.repomon]]
name = "origin/feature/testing"
interval = "1m"

[[branch.repomon-config]]
name = "origin/master"
interval = "1m"
"#;

    fn setup_branches() -> Branches {
        let master = Branch {
            name: "origin/master".to_string(),
            interval: "1m".to_string(),
        };

        let feature_testing = Branch {
            name: "origin/feature/testing".to_string(),
            interval: "1m".to_string(),
        };

        let repomon_branches = vec![master.clone(), feature_testing];
        let blah_branches = vec![master.clone()];
        let repomon_config_branches = vec![master];

        let mut branch_map = BTreeMap::new();
        branch_map.insert("repomon".to_string(), repomon_branches);
        branch_map.insert("repomon-config".to_string(), repomon_config_branches);
        branch_map.insert("blah".to_string(), blah_branches);

        Branches {
            branch_map: branch_map,
        }
    }

    fn test_branches(branches: &Branches) {
        let branch_map = branches.branch_map();
        assert_eq!(branch_map.keys().len(), 3);
        assert!(branch_map.contains_key("repomon"));
        assert!(branch_map.contains_key("repomon-config"));
        assert!(branch_map.contains_key("blah"));

        let mut branches = branch_map
            .get("repomon")
            .ok_or("invalid key")
            .expect("Unable to lookup repomon repo");
        assert_eq!(branches.len(), 2);
        branches = branch_map
            .get("repomon-config")
            .ok_or("invalid key")
            .expect("Unable to lookup repomon repo");
        assert_eq!(branches.len(), 1);
        branches = branch_map
            .get("blah")
            .ok_or("invalid key")
            .expect("Unable to lookup repomon repo");
        assert_eq!(branches.len(), 1);
    }

    #[test]
    fn serialize() {
        let branches = setup_branches();
        let toml = toml::to_string(&branches).expect("Unable to serialize to TOML");
        assert_eq!(TEST_TOML, toml);
    }

    #[test]
    fn deserialize() {
        let branches: Branches = toml::from_str(TEST_TOML).expect("Unable to deserialize TOML");
        test_branches(&branches);
    }

    #[test]
    fn empty_reader() {
        let mut cursor = Cursor::new(vec![]);
        match super::read_toml(&mut cursor) {
            Ok(_) => assert!(false, "0 bytes read should error"),
            Err(_) => assert!(true),
        }
    }

    #[test]
    fn read_toml() {
        let mut reader = Cursor::new(TEST_TOML);

        match super::read_toml(&mut reader) {
            Ok(branches) => test_branches(&branches),
            Err(_) => assert!(false, "Unable to parse TOML"),
        }
    }

    #[test]
    fn write_toml() {
        let mut buf = [0; 5000];
        let branches = setup_branches();
        {
            let mut writer = Cursor::new(&mut buf[..]);
            match super::write_toml(&branches, &mut writer) {
                Ok(_) => {}
                Err(_) => assert!(false, "Unable to write TOML"),
            }
        }

        let filtered = buf.iter().filter(|x| **x > 0).cloned().collect::<Vec<u8>>();
        assert_eq!(
            TEST_TOML,
            String::from_utf8(filtered).expect("Invalid UTF-8 in result")
        );
    }
}