//! Operation log objects (spec §12.1): every mutation of local repository

//! state records an `Op` whose `view` is the complete set of references and

//! workspaces afterwards.

//!

//! Encoding: `bookmarks` is an array of `[name, [heads]]` sorted by name and

//! `workspaces` an array of `[workspace_id, change_hash]` sorted by id, since

//! canonical maps carry only integer keys.

use crate::cbor::{self, Value};

use crate::hash::{hash_object, ChangeHash, ObjectRef, ObjectType};

use crate::ids::WorkspaceId;

use crate::objects::{array, bytes, check_version, field, oref, text, Hlc, ObjectError, FORMAT_VERSION};

use std::collections::BTreeMap;

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct View {

    pub bookmarks: BTreeMap<String, Vec<ChangeHash>>,

    pub workspaces: BTreeMap<WorkspaceId, ChangeHash>,

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Op {

    pub parents: Vec<ObjectRef>,

    pub hlc: Hlc,

    pub command: String,

    pub view: View,

}

impl View {

    fn to_value(&self) -> Value {

        Value::map([

            (

                0,

                Value::Array(

                    self.bookmarks

                        .iter()

                        .map(|(n, hs)| {

                            Value::Array(vec![

                                Value::Text(n.clone()),

                                Value::Array(hs.iter().map(|h| Value::Bytes(h.0.to_vec())).collect()),

                            ])

                        })

                        .collect(),

                ),

            ),

            (

                1,

                Value::Array(

                    self.workspaces

                        .iter()

                        .map(|(w, h)| Value::Array(vec![Value::Bytes(w.0.to_vec()), Value::Bytes(h.0.to_vec())]))

                        .collect(),

                ),

            ),

        ])

    }

    fn from_value(v: &Value) -> Result<View, ObjectError> {

        let m = v.as_map().ok_or_else(|| ObjectError::Schema("view: expected map".into()))?;

        let mut view = View::default();

        for b in array(field(m, 0, "bookmarks")?, "bookmarks")? {

            let pair = array(b, "bookmark")?;

            if pair.len() != 2 {

                return Err(ObjectError::Schema("bookmark: expected [name, heads]".into()));

            }

            let name = text(&pair[0], "bookmark name")?.to_owned();

            let mut heads = array(&pair[1], "heads")?.iter().map(|h| oref(h, "head")).collect::<Result<Vec<_>, _>>()?;

            heads.sort();

            heads.dedup();

            view.bookmarks.insert(name, heads);

        }

        for w in array(field(m, 1, "workspaces")?, "workspaces")? {

            let pair = array(w, "workspace")?;

            if pair.len() != 2 {

                return Err(ObjectError::Schema("workspace: expected [id, change]".into()));

            }

            let id = WorkspaceId::from_slice(bytes(&pair[0], "workspace id")?)

                .ok_or_else(|| ObjectError::Schema("workspace id: expected 16 bytes".into()))?;

            view.workspaces.insert(id, oref(&pair[1], "workspace change")?);

        }

        Ok(view)

    }

}

/// Suffix on the `command` of operations recorded by an automatic

/// working-copy snapshot rather than by a user command.

pub const SNAPSHOT_SUFFIX: &str = " (snapshot)";

impl Op {

    /// Whether this operation only recorded a working-copy snapshot.

    pub fn is_snapshot(&self) -> bool {

        self.command.ends_with(SNAPSHOT_SUFFIX)

    }

    pub fn to_value(&self) -> Value {

        Value::map([

            (0, Value::Uint(FORMAT_VERSION)),

            (1, Value::Array(self.parents.iter().map(|p| Value::Bytes(p.0.to_vec())).collect())),

            (2, self.hlc.to_value()),

            (3, Value::Text(self.command.clone())),

            (4, self.view.to_value()),

        ])

    }

    pub fn encode(&self) -> Vec<u8> {

        cbor::encode(&self.to_value())

    }

    pub fn hash(&self) -> ObjectRef {

        hash_object(ObjectType::Op, &self.encode())

    }

    pub fn decode(b: &[u8]) -> Result<Op, ObjectError> {

        let v = cbor::decode(b)?;

        let m = v.as_map().ok_or_else(|| ObjectError::Schema("op: expected map".into()))?;

        check_version(m)?;

        Ok(Op {

            parents: array(field(m, 1, "parents")?, "parents")?.iter().map(|p| oref(p, "parent")).collect::<Result<Vec<_>, _>>()?,

            hlc: Hlc::from_value(field(m, 2, "hlc")?)?,

            command: text(field(m, 3, "command")?, "command")?.to_owned(),

            view: View::from_value(field(m, 4, "view")?)?,

        })

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn op_round_trip() {

        let mut view = View::default();

        view.bookmarks.insert("main".into(), vec![ObjectRef([2; 32]), ObjectRef([1; 32])]);

        view.bookmarks.insert("dev".into(), vec![]);

        view.workspaces.insert(WorkspaceId([5; 16]), ObjectRef([9; 32]));

        let op = Op { parents: vec![ObjectRef([7; 32])], hlc: Hlc { wall_ms: 5, logical: 1 }, command: "oxy commit".into(), view };

        let d = Op::decode(&op.encode()).unwrap();

        // Heads are normalized to sorted order on decode.

        assert_eq!(d.view.bookmarks["main"], vec![ObjectRef([1; 32]), ObjectRef([2; 32])]);

        assert_eq!(d.command, op.command);

        assert_eq!(d.parents, op.parents);

        assert_eq!(d.hash(), Op::decode(&d.encode()).unwrap().hash());

    }

}