mod vector_clock;

use uuid::Uuid;

use crate::vector_clock::VectorClock;

pub struct Doc {
    ops: Vec<Op>,
}

impl Doc {
    pub fn new(actor_id: &Uuid) -> Self {
        Self {
            ops: vec![Op {
                id: Uuid::now_v7(),
                clock: VectorClock::new().inc(actor_id),
                payload: OpPayload::Init,
            }],
        }
    }

    pub fn append_op(&mut self, payload: OpPayload, actor_id: &Uuid) {
        let clock = self
            .ops
            .last()
            .expect("doc should have at least an Init op")
            .clock
            .inc(actor_id);

        self.ops.push(Op {
            id: Uuid::now_v7(),
            clock,
            payload,
        });
    }

    pub fn realize(&self) -> RealizedDoc {
        let mut realized = RealizedDoc::default();
        for op in &self.ops {
            op.apply(&mut realized);
        }
        realized
    }
}

pub struct Op {
    id: Uuid,
    payload: OpPayload,
    clock: VectorClock,
}

impl Op {
    fn apply(&self, realized: &mut RealizedDoc) {
        match self.payload {
            OpPayload::Init => {}
            OpPayload::ChangeSubdivisions { rowId } => {}
        }
    }
}

pub enum OpPayload {
    Init,
    ChangeSubdivisions { rowId: Uuid },
}

pub struct RealizedDoc {
    grids: Vec<Grid>,
}

impl Default for RealizedDoc {
    fn default() -> Self {
        RealizedDoc {
            grids: vec![Grid {}],
        }
    }
}

pub struct Grid {}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn realize_doc() {
        let actor_id = Uuid::now_v7();
        let doc = Doc::new(&actor_id);
        let realized = doc.realize();

        assert!(realized.grids.len() == 1);
    }
}