use super::template::{DayTrait, ResultType};
use crate::common::{file::split_lines, pos::Pos};
use itertools::Itertools;
use once_cell::sync::Lazy;
use regex::Regex;
use std::{collections::HashSet, num::ParseIntError};
use thiserror::Error;

const DAY_NUMBER: usize = 15;

pub struct Day;

impl DayTrait for Day {
    fn get_day_number(&self) -> usize {
        DAY_NUMBER
    }

    fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
        let lines = split_lines(lines).collect_vec();
        if lines.len() < 2 {
            Err(SensorError::ToFewLines)?;
        }
        let row = lines[0].parse()?;
        let (sensors, beacons) = Day::parse_all(&lines[1..])?;
        let result = Day::count_coverage_at(&sensors, &beacons, row);
        Ok(ResultType::Integer(result))
    }

    fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
        let lines = split_lines(lines).collect_vec();
        if lines.len() < 2 {
            Err(SensorError::ToFewLines)?;
        }
        let (sensors, _) = Day::parse_all(&lines[1..])?;
        let mid_lines = Day::dividing_lines(&sensors);
        let points = mid_lines
            .iter()
            .tuple_combinations()
            .filter_map(|(first, second)| first.cross(second))
            .filter(|pos| sensors.iter().all(|sensor| !sensor.contains(pos)))
            .dedup()
            .collect::<Vec<_>>();

        if points.len() != 1 {
            Err(SensorError::NotExactlyOneResult(points.len()))?;
        }

        let point = points.first().unwrap();
        Ok(ResultType::Integer(point.x() * 4000000 + point.y()))
    }
}

impl Day {
    fn parse_all(lines: &[&str]) -> Result<(HashSet<Sensor>, HashSet<Pos<i64>>), SensorError> {
        let mut sensors = HashSet::new();
        let mut beacons = HashSet::new();
        for line in lines {
            let (sensor, beacon) = Sensor::parse(line)?;
            sensors.insert(sensor);
            beacons.insert(beacon);
        }
        Ok((sensors, beacons))
    }

    fn count_coverage_at(sensors: &HashSet<Sensor>, beacons: &HashSet<Pos<i64>>, row: i64) -> i64 {
        let ranges = sensors
            .iter()
            .filter_map(|sensor| sensor.range_at(row))
            .collect::<Vec<_>>();
        let merged: i64 = Range::merge_all(&ranges)
            .iter()
            .map(|range| range.width())
            .sum();
        let sensors = sensors
            .iter()
            .filter(|sensor| sensor.pos.y() == row)
            .count() as i64;
        let beacons = beacons.iter().filter(|beacons| beacons.y() == row).count() as i64;

        merged - (sensors + beacons)
    }

    fn dividing_lines(sensors: &HashSet<Sensor>) -> Vec<Line> {
        sensors
            .iter()
            .tuple_combinations()
            .filter_map(|(first, second)| Line::create(first, second))
            .collect()
    }
}

#[derive(Debug, Error)]
enum SensorError {
    #[error("Not an Integer")]
    NotAnInt(#[from] ParseIntError),

    #[error("Unknown line: {0}")]
    UnknownLine(String),

    #[error("Did not find exactly one point for the sensor: {0}")]
    NotExactlyOneResult(usize),

    #[error("Too few lines in input.txt")]
    ToFewLines,
}

#[derive(Debug)]
struct Line {
    start: Pos<i64>,
    is_up: bool,
    steps: i64,
}

impl Line {
    pub fn create(first: &Sensor, second: &Sensor) -> Option<Line> {
        if first.border_distance(second) != 2 {
            return None;
        }

        let (one, two) = if first.pos.x() < second.pos.x() {
            (first, second)
        } else {
            (second, first)
        };

        let start;
        let is_up;
        if one.pos.y() < two.pos.y() {
            is_up = true;
            if one.pos.y() + one.radius <= two.pos.y() {
                start = Pos::new(one.pos.x(), one.pos.y() + one.radius + 1);
            } else {
                start = Pos::new(two.pos.x() - two.radius - 1, two.pos.y());
            }
        } else {
            is_up = false;
            if one.pos.y() - one.radius >= two.pos.y() {
                start = Pos::new(one.pos.x(), one.pos.y() - one.radius - 1);
            } else {
                start = Pos::new(two.pos.x() - two.radius - 1, two.pos.y());
            }
        }
        let steps = two.pos.x().min(one.pos.x() + one.radius) - start.x();

        Some(Line {
            start,
            is_up,
            steps,
        })
    }

    fn cross(&self, other: &Line) -> Option<Pos<i64>> {
        if self.is_up == other.is_up {
            return None;
        }
        let (bottom_up, top_down) = if self.is_up {
            (self, other)
        } else {
            (other, self)
        };

        let r2 =
            bottom_up.start.x() + bottom_up.start.y() - (top_down.start.x() + top_down.start.y());
        if r2 % 2 != 0 {
            return None;
        }

        let r = r2 / 2;
        if r < 0 || r > top_down.steps {
            return None;
        }

        let pos = top_down.start + Pos::splat(r);
        Some(pos)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct Range(i64, i64);

impl Range {
    fn overlaps(&self, other: &Range) -> bool {
        self.0 <= other.1 && other.0 <= self.1
    }

    pub fn width(&self) -> i64 {
        self.1 - self.0 + 1
    }

    pub fn merge_all(ranges: &[Range]) -> Vec<Range> {
        let mut ranges: Vec<Range> = ranges.iter().sorted().copied().collect();
        assert!(!ranges.is_empty());
        loop {
            let mut next = vec![];
            let mut merged = false;
            let mut current = ranges[0];
            for range in &ranges[1..] {
                if current.overlaps(range) {
                    current = Range(current.0, current.1.max(range.1));
                    merged = true;
                } else {
                    next.push(current);
                    current = *range;
                }
            }
            next.push(current);

            if merged {
                ranges = next;
            } else {
                return next;
            }
        }
    }
}

#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
struct Sensor {
    pos: Pos<i64>,
    radius: i64,
}

static SENSOR: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"x=(-?\d+), y=(-?\d+).*x=(-?\d+), y=(-?\d+)").unwrap());

impl Sensor {
    pub fn parse(line: &str) -> Result<(Sensor, Pos<i64>), SensorError> {
        let caps = SENSOR
            .captures(line)
            .ok_or(SensorError::UnknownLine(line.to_owned()))?;
        let sensor_x = caps.get(1).unwrap().as_str().parse()?;
        let sensor_y = caps.get(2).unwrap().as_str().parse()?;
        let beacon_x = caps.get(3).unwrap().as_str().parse()?;
        let beacon_y = caps.get(4).unwrap().as_str().parse()?;
        let sensor = Pos::new(sensor_x, sensor_y);
        let beacon = Pos::new(beacon_x, beacon_y);
        let radius = sensor.taxicab(&beacon);
        Ok((
            Sensor {
                pos: sensor,
                radius,
            },
            beacon,
        ))
    }

    pub fn range_at(&self, y: i64) -> Option<Range> {
        let distance = (self.pos.y() - y).abs();
        if distance > self.radius {
            None
        } else {
            let extent = self.radius - distance;
            Some(Range(self.pos.x() - extent, self.pos.x() + extent))
        }
    }

    pub fn border_distance(&self, other: &Sensor) -> i64 {
        let distance = self.pos.taxicab(&other.pos);
        distance - self.radius - other.radius
    }

    pub fn contains(&self, pos: &Pos<i64>) -> bool {
        self.pos.taxicab(pos) <= self.radius
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::common::file::read_string;
    use anyhow::Result;
    #[test]
    fn test_parse() -> Result<()> {
        let input = "Sensor at x=2, y=18: closest beacon is at x=-2, y=15";
        let expected = (
            Sensor {
                pos: Pos::new(2, 18),
                radius: 7,
            },
            Pos::new(-2, 15),
        );
        let result = Sensor::parse(input)?;
        assert_eq!(result, expected);

        Ok(())
    }

    #[test]
    fn test_width() {
        let sensor = Sensor {
            pos: Pos::new(8, 7),
            radius: 9,
        };
        assert_eq!(sensor.range_at(17), None);
        assert_eq!(sensor.range_at(7), Some(Range(-1, 17)));
        assert_eq!(sensor.range_at(10), Some(Range(2, 14)));
    }

    #[test]
    fn test_merge() {
        let input = vec![Range(4, 10), Range(1, 3), Range(5, 9), Range(8, 12)];
        let expected = vec![Range(1, 3), Range(4, 12)];
        assert_eq!(Range::merge_all(&input), expected);
    }

    #[test]
    fn test_part1() -> Result<()> {
        let day = Day {};
        let lines = read_string(day.get_day_number(), "example01.txt")?;
        let expected = ResultType::Integer(26);
        let result = day.part1(&lines)?;
        assert_eq!(result, expected);

        Ok(())
    }

    #[test]
    fn test_part2() -> Result<()> {
        let day = Day {};
        let lines = read_string(day.get_day_number(), "example01.txt")?;
        let expected = ResultType::Integer(56000011);
        let result = day.part2(&lines)?;
        assert_eq!(result, expected);

        Ok(())
    }
}