use crate::converter::StreamConverter_Char;
use crate::{Keyword, KeywordComparatorIterator};
use std::marker::PhantomData;

struct KeywordComparatorConverter<
    'keyword,
    'converter,
    C: Copy,
    W: StreamConverter_Char<C>,
    I: KeywordComparatorIterator<'keyword, W::WC>,
> {
    _orig: I,
    _converter: &'converter W,
    __phantom: PhantomData<(&'keyword (), C)>,
}

impl<
    'keyword,
    'converter,
    C: Copy,
    W: StreamConverter_Char<C>,
    I: KeywordComparatorIterator<'keyword, W::WC>,
> KeywordComparatorIterator<'keyword, C>
    for KeywordComparatorConverter<'keyword, 'converter, C, W, I>
{
    fn consume(&mut self, c: C) -> bool {
        self._orig.consume(self._converter.convertChar(c))
    }
}

pub struct KeywordDeconverted<
    'keyword,
    'converter,
    C: Copy,
    W: StreamConverter_Char<C>,
    I: Keyword<W::WC>,
> {
    _orig: &'keyword I,
    _converter: &'converter W,
    __phantom: PhantomData<C>,
}

impl<'keyword, 'converter, C: Copy, W: StreamConverter_Char<C>, I: Keyword<W::WC>>
    KeywordDeconverted<'keyword, 'converter, C, W, I>
{
    pub fn deconvert(kw: &'keyword I, converter: &'converter W) -> Self {
        return KeywordDeconverted {
            _orig: kw,
            _converter: converter,
            __phantom: PhantomData::default(),
        };
    }
}

impl<'keyword, 'converter, C: Copy, W: StreamConverter_Char<C>, I: Keyword<W::WC>> Keyword<C>
    for KeywordDeconverted<'keyword, 'converter, C, W, I>
{
    fn startComparation<'self_>(
        &'self_ self,
        expectedLen: usize,
    ) -> Option<impl KeywordComparatorIterator<'self_, C>> {
        return self
            ._orig
            .startComparation(expectedLen)
            .map(|it| KeywordComparatorConverter {
                _orig: it,
                _converter: self._converter,
                __phantom: PhantomData::default(),
            });
    }
}