// License: see LICENSE file at root directory of `master` branch

//! # Range

use std::{
    cmp::Ordering,
    hash::{Hash, Hasher},
    io::{self, Error, ErrorKind},
    marker::PhantomData,
    str::FromStr,
};

#[allow(deprecated)]
use crate::{
    Ops, RangeType,
};

/// # Range
///
/// _Note that by default, `Range` is inclusive at both sides._
#[derive(Debug, Eq, PartialEq, Clone)]
#[allow(deprecated)]
pub struct Range<R, U> where R: RangeType<U>, U: Ops {

    /// # Start
    start: R,

    /// # End
    end: R,

    /// # Phantom data
    phantom_data: PhantomData<U>,

}

#[allow(deprecated)]
impl<R, U> Range<R, U> where R: RangeType<U>, U: Ops {

    /// # Makes new instance
    ///
    /// Start can be smaller than end, equal to end, or larger than end. They will be handled properly.
    pub fn new(start: R, end: R) -> Self {
        Self {
            start: start.min(end),
            end: start.max(end),
            phantom_data: PhantomData,
        }
    }

    /// # Makes new instance from 1 value
    pub fn from(start: R) -> Self {
        Self::new(start, start)
    }

    /// # Start
    pub fn start(&self) -> R {
        self.start
    }

    /// # End
    pub fn end(&self) -> R {
        self.end
    }

    /// # Checks to see if this range contains given value
    ///
    /// The check is inclusive where `start <= v` and `v <= end`.
    pub fn contains(&self, v: &R) -> bool {
        &self.start <= v && v <= &self.end
    }

    /// # Checks to see if this range is full
    ///
    /// A full range contains all values of its type.
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// assert!(Range::new(i64::min_value(), i64::max_value()).is_full());
    /// assert!(Range::from(0).is_full() == false);
    /// ```
    pub fn is_full(&self) -> bool {
        self.start == R::minimum() && self.end == R::maximum()
    }

    /// # Expands self by `1`
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range: Range<i8, u8> = Range::new(-6, 9);
    /// assert!(range.expand(-7));
    /// assert!(range.expand(-9) == false);
    /// assert!(range.expand(0) == false);
    /// assert!(range.contains(&-7));
    /// ```
    pub fn expand(&mut self, v: R) -> bool {
        if &v < &self.start && &v.saturating_add_one() == &self.start {
            self.start = v;
            return true;
        }
        if &self.end < &v && &self.end.saturating_add_one() == &v {
            self.end = v;
            return true;
        }
        false
    }

    /// # Expands self
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range = Range::new(-1, 1);
    /// assert!(range.expand_more(9));
    /// assert_eq!(&range, &Range::new(-1, 9));
    /// assert!(range.expand_more(-9));
    /// assert_eq!(&range, &Range::new(-9, 9));
    /// assert!(range.expand_more(0) == false);
    /// ```
    pub fn expand_more(&mut self, v: R) -> bool {
        if self.contains(&v) {
            return false;
        }
        if &self.start > &v {
            self.start = v;
            return true;
        }
        if &self.end < &v {
            self.end = v;
            return true;
        }
        false
    }

    /// # Shrinks start by `1`
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range = Range::new(8, 9);
    /// assert!(range.shrink_start(8) == false);
    /// assert!(range.shrink_start(9));
    /// assert!(range.shrink_start(10) == false);
    /// assert_eq!(range, Range::from(9));
    /// ```
    pub fn shrink_start(&mut self, v: R) -> bool {
        if &self.start < &v && &v <= &self.end && &self.start.saturating_add_one() == &v {
            self.start = v;
            return true;
        }
        false
    }

    /// # Shrinks start
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range = Range::new(9, 99);
    /// assert!(range.shrink_start_more(9) == false);
    /// assert!(range.shrink_start_more(90));
    /// assert!(range.shrink_start_more(1_000) == false);
    /// assert_eq!(range, Range::new(90, 99));
    /// ```
    pub fn shrink_start_more(&mut self, v: R) -> bool {
        if &self.start < &v && &v <= &self.end {
            self.start = v;
            return true;
        }
        false
    }

    /// # Shrinks end by `1`
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range = Range::new(-5, 5);
    /// assert!(range.shrink_end(5) == false);
    /// assert!(range.shrink_end(6) == false);
    /// assert!(range.shrink_end(3) == false);
    /// assert!(range.shrink_end(4));
    /// assert!(range.shrink_end(-10) == false);
    /// assert_eq!(range, Range::new(-5, 4));
    /// ```
    pub fn shrink_end(&mut self, v: R) -> bool {
        if &v < &self.end && &v >= &self.start && &v.saturating_add_one() == &self.end {
            self.end = v;
            return true;
        }
        false
    }

    /// # Shrinks end
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// let mut range = Range::new(-10, 10);
    /// assert!(range.shrink_end_more(20) == false);
    /// assert!(range.shrink_end_more(6));
    /// assert!(range.shrink_end_more(-30) == false);
    /// assert_eq!(range, Range::new(-10, 6));
    /// ```
    pub fn shrink_end_more(&mut self, v: R) -> bool {
        if &self.start <= &v && &v < &self.end {
            self.end = v;
            return true;
        }
        false
    }

    /// # Merges with other range
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// assert_eq!(Range::new(0_u64, 6).merge(&Range::new(5, 9)), Some(Range::new(0, 9)));
    /// assert_eq!(Range::new(-1_i8, 6).merge(&Range::new(8, 9)), None);
    /// ```
    pub fn merge(&self, other: &Self) -> Option<Self> {
        match self.cmp(other) {
            Ordering::Less => match self.end.saturating_add_one() >= other.start {
                true => Some(Self::new(self.start.min(other.start), self.end.max(other.end))),
                false => None,
            },
            Ordering::Equal => Some(Self::new(self.start, self.end)),
            Ordering::Greater => match other.end.saturating_add_one() >= self.start {
                true => Some(Self::new(self.start.min(other.start), self.end.max(other.end))),
                false => None,
            },
        }
    }

    /// # _Estimates_ size of this range
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// assert_eq!(Range::new(0_u8, 1).estimate_size(), 2);
    /// assert_eq!(Range::new(-1_i16, 1).estimate_size(), 3_u16);
    /// assert_eq!(Range::new(-3_i32, -1).estimate_size(), 3_u32);
    /// assert_eq!(Range::new(i8::min_value(), i8::max_value()).estimate_size(), u8::max_value());
    /// ```
    pub fn estimate_size(&self) -> U {
        self.start.estimate_size(self.end)
    }

    /// # Makes new iterator
    ///
    /// ## Examples
    ///
    /// ```
    /// use dia_range::Range;
    ///
    /// assert_eq!(Range::new(-1, 1).iter().sum::<i8>(), 0);
    /// assert_eq!(Range::from(u16::max_value()).iter().sum::<u16>(), u16::max_value());
    ///
    /// let n = i16::from(i8::max_value());
    /// assert_eq!(Range::new(n - 1, n).iter().sum::<i16>(), n * 2 - 1);
    /// ```
    pub fn iter(&self) -> crate::RangeIter<R> {
        crate::RangeIter::new(self.start, self.end)
    }

}

#[allow(deprecated)]
impl<R, U> Ord for Range<R, U> where R: RangeType<U>, U: Ops {

    fn cmp(&self, other: &Self) -> Ordering {
        match self.start.cmp(&other.start) {
            Ordering::Equal => self.end.cmp(&other.end),
            other => other,
        }
    }

}

#[allow(deprecated)]
impl<R, U> PartialOrd for Range<R, U> where R: RangeType<U>, U: Ops {

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

}

#[allow(deprecated)]
impl<R, U> Hash for Range<R, U> where R: RangeType<U>, U: Ops {

    fn hash<H: Hasher>(&self, h: &mut H) {
        self.start.hash(h);
        self.end.hash(h);
    }

}

#[allow(deprecated)]
impl<R, U> AsRef<Range<R, U>> for Range<R, U> where R: RangeType<U>, U: Ops {

    fn as_ref(&self) -> &Self {
        self
    }

}

/// # Parsing [`Range`][crate::Range] from strings
///
/// ## Syntax
///
/// ```ignore
/// [start]..[end]
/// ```
///
/// - `start` must be smaller than or equal to `end`.
/// - If `start` is absent, minimum value will be used.
/// - If `end` is absent, maximum value will be used.
/// - ***Note:*** the syntax is similar to Rust's ranges, however the meaning is _completely different_. By default, [`Range`][crate::Range] is
///   inclusive at both sides. So this implementation treats input values exactly the same.
/// - _Some_ white spaces are allowed among `start`, `..` and `end`.
///
/// [crate::Range]: struct.Range.html
#[allow(deprecated)]
impl<R, U> FromStr for Range<R, U> where R: RangeType<U>, U: Ops {

    type Err = Error;

    fn from_str(s: &str) -> io::Result<Self> {
        const SEPARATOR: &'static str = "..";

        if s.len() >= u128::max_value().to_string().len().max(usize::max_value().to_string().len()).saturating_mul(3) {
            return Err(Error::new(ErrorKind::InvalidData, format!("String too large: {:?}", s)));
        }

        let (start, end) = match s.find(SEPARATOR) {
            Some(idx) => (s[..idx].trim(), s[idx + SEPARATOR.len()..].trim()),
            None => return Err(Error::new(ErrorKind::InvalidData, format!("Missing separator ({:?}): {:?}", SEPARATOR, s))),
        };
        let start = match start.is_empty() {
            true => R::minimum(),
            false => match R::from_str(start) {
                Ok(start) => start,
                Err(_) => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid start value: {:?}", start))),
            },
        };
        let end = match end.is_empty() {
            true => R::maximum(),
            false => match R::from_str(end) {
                Ok(end) => end,
                Err(_) => return Err(Error::new(ErrorKind::InvalidData, format!("Invalid end value: {:?}", end))),
            },
        };
        match start <= end {
            true => Ok(Self::new(start, end)),
            false => Err(Error::new(
                ErrorKind::InvalidData, format!("Start must be smaller than or equal to end, not this: {} > {}", start, end)
            )),
        }
    }

}

/// # Merges ranges
///
/// The result will be sorted in ascending order.
///
/// ## Examples
///
/// ```
/// use dia_range::Range;
///
/// assert_eq!(
///     dia_range::merge(vec![Range::new(8, 9), Range::new(0, 1), Range::new(2, 5)].into_iter()),
///     &[Range::new(0, 5), Range::new(8, 9)],
/// );
/// ```
#[allow(deprecated)]
pub fn merge<I, R, U>(ranges: I) -> Vec<Range<R, U>> where I: Iterator<Item=Range<R, U>>, R: RangeType<U>, U: Ops {
    let mut ranges: Vec<_> = ranges.collect();
    ranges.sort();

    let mut result = Vec::with_capacity(ranges.len());
    let mut last_range: Option<Range<R, U>> = None;
    for r in ranges {
        match last_range {
            Some(last) => match last.merge(&r) {
                Some(new) => last_range = Some(new),
                None => {
                    result.push(last);
                    last_range = Some(r);
                },
            },
            None => last_range = Some(r),
        };
    }

    if let Some(last) = last_range {
        result.push(last);
    }

    result.shrink_to_fit();
    result
}