// Copyright (C) 2021-2022 Soni L.
// SPDX-License-Identifier: MIT OR Apache-2.0

//! Datafu Patterns.

use std::borrow::Borrow;
use std::collections::BTreeMap;

use serde::de::Deserialize;
use serde::de::DeserializeSeed as _;
use serde::de::Deserializer;
use serde::ser::Serialize;

use crate::Predicate;
use crate::errors::PatternError;
use crate::parser::parse;
use crate::vm;
use crate::vm::PatternConstants;
use crate::vm::MAX_CALLS;

/// A compiled Datafu pattern.
///
/// # Examples
///
/// ```
/// use datafu::Pattern;
///
/// let pattern = Pattern::<()>::compile::<&str, &str>(
///     "->['value']'hello'",
///     None, None
/// ).expect("failed to compile pattern");
/// ```
pub struct Pattern<O: Serialize> {
    consts: PatternConstants<O>,
}

impl<O: Serialize> Pattern<O> {
    /// Matches the pattern against an input.
    pub fn deserialize<'de, Der, De>(&self, der: Der) -> Result<De, Der::Error>
    where
        Der: Deserializer<'de>,
        De: Deserialize<'de>,
    {
        let mut err = Default::default();
        let mut frames = Default::default();
        //let mut output = Default::default();
        let interp = vm::Interpreter::new(
            &self.consts,
            &mut err,
            &mut frames,
            //&mut output,
        );
        let (mut packs, obj) = vm::Packer::new(
            interp,
            MAX_CALLS,
        ).deserialize(der)?;
        // this should always be None
        debug_assert!(obj.is_none());
        debug_assert!(packs.len() == 1);
        let pack = packs.pop().unwrap();
        let de = De::deserialize(vm::Unpacker::new(pack, MAX_CALLS));
        todo!()
    }
}

pub struct PatternBuilder<'s, PKey=&'static str, OKey=&'static str, O=()> {
    input: &'s str,
    preds: Option<BTreeMap<PKey, Box<Predicate>>>,
    objs: Option<BTreeMap<OKey, O>>,
}

impl<'s> PatternBuilder<'s> {
    /// Creates a PatternBuilder for a given pattern.
    ///
    /// # Examples
    ///
    /// ```
    /// use datafu::Pattern;
    /// use serde::Deserialize;
    /// use charx;
    ///
    /// let preds = vec![
    ///     ("dict", datafu::pred(|v| { todo!() })),
    ///     ("str", datafu::pred(|v| { String::deserialize(v).is_ok() })),
    ///     ("commit", datafu::pred(|v| {
    ///         if let Ok(v) = String::deserialize(v) {
    ///             v.len() == 40 && v.trim_start_matches(
    ///                 charx::is_ascii_hexdigit
    ///             ).is_empty()
    ///         } else {
    ///             false
    ///         }
    ///     })),
    ///     ("uri", datafu::pred(|v| { todo!() })),
    ///     ("bool", datafu::pred(|v| { todo!() })),
    /// ].into_iter().collect();
    /// let pattern = Pattern::<()>::compile::<&str, &str>("
    ///        ->'projects':$dict
    ///          ->commit[:?$str:?$commit]:?$dict
    ///            ->url[:?$str:?$uri]:?$dict
    ///              ->branch:?$dict
    ///                (->active'active'?:?$bool)
    ///                (->federate'federate'?:?$bool)?",
    ///     Some(preds), None
    /// ).expect("failed to compile pattern");
    /// ```
    pub fn for_pattern(pattern: &'s str) -> Self {
        Self {
            input: pattern,
            preds: None,
            objs: None,
        }
    }
}

impl<'s, PKey, OKey, O> PatternBuilder<'s, PKey, OKey, O>
where
    PKey: Borrow<str> + Ord,
    OKey: Borrow<str> + Ord,
    O: Serialize,
{
    /// Compiles the pattern.
    pub fn compile(self) -> Result<Pattern<O>, PatternError<'s>> {
        Ok(Pattern {
            consts: parse(self.input, self.preds, self.objs)?
        })
    }
}