pub enum CounterKey {
    Identified((Namespace, String)),
    Simple((Namespace, SimpleCounterKey)),
    Qualified((Namespace, SimpleCounterKey, Vec<String>)),
}

impl CounterKey {
    fn namespace(&self) -> &Namespace {
        match self {
            CounterKey::Identified((ns, _)) => ns,
            CounterKey::Simple((ns, _)) => ns,
            CounterKey::Qualified((ns, _, _)) => ns,
        }
    }
}

impl Eq for CounterKey {}

impl PartialEq<Self> for CounterKey {
    fn eq(&self, other: &Self) -> bool {
        self.cmp(other) == Ordering::Equal
    }
}

impl PartialOrd<Self> for CounterKey {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for CounterKey {
    fn cmp(&self, other: &Self) -> Ordering {
        match self.namespace().cmp(other.namespace()) {
            Ordering::Equal => {
                match self {
                    CounterKey::Identified((_, id)) => {
                        match other {
                            CounterKey::Identified((_, other)) => id.cmp(other),
                            _ => Ordering::Less,
                        }
                    }
                    CounterKey::Simple((_, key)) => {
                        match other {
                            CounterKey::Identified(_) => Ordering::Greater,
                            CounterKey::Simple((_, other)) => key.cmp(other),
                            CounterKey::Qualified(_) => Ordering::Less,
                        }
                    }
                    CounterKey::Qualified((_, key, qualifiers)) => {
                        match other {
                            CounterKey::Identified(_) => Ordering::Greater,
                            CounterKey::Simple(_) => Ordering::Greater,
                            CounterKey::Qualified((_, other_key, other_qualifiers)) => {
                                match key.cmp(other_key) {
                                    Ordering::Equal => qualifiers.cmp(other_qualifiers),
                                    other => other,
                                }
                            }
                        }
                    }
                }
            },
            other => other,
        }
    }
}

#[derive(Eq, PartialEq, Ord, PartialOrd, Debug)]
pub struct SimpleCounterKey {
    seconds: u64,
    conditions: Vec<String>,
}

impl From<&Limit> for CounterKey {
    fn from(limit: &Limit) -> Self {
        let mut conditions = Vec::from(limit.conditions());
        conditions.sort();
        let mut variables = Vec::from(limit.variables());
        variables.sort();

        Self {
            namespace: limit.namespace().clone(),
            seconds: limit.seconds(),
            conditions,
            variables,
        }
    }
}