type Point = (f32, f32);

#[derive(Debug)]
struct Line { // ax + by + c = 0
    a: f32,
    b: f32,
    c: f32,
}

#[derive(Debug)]
struct Segment { // ax + by + c = 0
    l: Line,
    p: Point,
    q: Point,
}

impl Line {
    fn new (p1: Point, p2: Point) -> Line {
        if p1.0 == p2.0 {
            Line {
                a: 1.0,
                b: 0.0,
                c: -p1.0,
            }
        } else if p1.1 == p2.1 {
            Line {
                a: 0.0,
                b: 1.0,
                c: -p1.1,
            }
        } else {
            let m: f32 = (p2.1 - p1.1) / (p2.0 - p1.0);
            let c: f32 = p1.1 - m * p1.0;
            Line {
                a: m,
                b: -1f32,
                c: c,
            }
        }
    }
}

impl Segment {
    fn new(p: Point, q: Point) -> Segment {
        let l = Line::new(p, q);
        Segment {
            l: l,
            p: p,
            q: q,
        }
    }
    fn intersects(&self, r: Point, pt: Point) -> bool {
        let a1: f32 = self.l.a;
        let b1: f32 = self.l.b;
        let c1: f32 = self.l.c;
        let p = r;
        let l = Line::new(p, pt);
        let a2: f32 = l.a;
        let b2: f32 = l.b;
        let c2: f32 = l.c;
        if a1 == a2 && b1 == b2 && c1 == c2 {
            self.p.0 > p.0 && self.p.1 > p.1
        } else {
            // println!("{}x + {}y + {} = 0\t\t{}x + {}y + {} = 0", a1, b1, c1, a2, b2, c2);
            let xx: f32 = ( b1 * c2 - b2 * c1 ) / ( a1 * b2 - a2 * b1 );
            let yy: f32 = ( a2 * c1 - a1 * c2 ) / ( a1 * b2 - a2 * b1 );
            let xmax = if self.p.0 > self.q.0 { self.p.0 } else {self.q.0 };
            let xmin = self.p.0 + self.q.0 - xmax;
            let ymax = if self.p.1 > self.q.1 { self.p.1 } else {self.q.1 };
            let ymin = self.p.1 + self.q.1 - ymax;
            // println!("{}, {}", xx, yy);
            if xx > pt.0 {
                false
            } else if xmin == xmax {
                ( yy > ymin ) && ( yy <= ymax )
            } else {
                ( xx > xmin ) && ( xx <= xmax )
            }
        }
    }
}

type Segments = Vec<Segment>;

fn test(ls: Segments, pt: Point) -> bool {
    let mut out1 = false;
    let mut out2 = false;
    let r1: Point = (-14., 0.);
    let r2: Point = (-14., 1.);
    for s in &ls {
        let cur1 = s.intersects(r1, pt);
        if cur1 {
            out1 = !out1;
        }
    }
    for s in &ls {
        let cur2 = s.intersects(r2, pt);
        if cur2 {
            out2 = !out2;
        }
    }
    println!("{}, {}", out1, out2);
    out1 || out2
}

fn point_in_poly(poly: &[Point], point: Point) -> bool {
    let mut ls: Segments = Vec::new();
    for i in 0 .. poly.len() - 1 {
        ls.push(Segment::new(poly[i], poly[i + 1]));
    }
    ls.push(Segment::new(poly[poly.len() - 1], poly[0]));
    let out = test(ls, point);
    // println!("{:?}, {:?})", poly, point);
    out
}

fn main() {
    let poly = [(3.6759505, 0.13828002), (3.9046004, 1.443813), (3.3530989, 3.5922122), (2.2569885, 3.5326672), (0.57010514, 4.242185), (-0.103441946, 4.069717), (-2.2492082, 4.00108), (-2.1071105, 2.1929216), (-3.603793, 2.210453), (-4.154597, 0.80724186), (-4.193355, -0.7821003), (-3.809928, -1.4759481), (-3.2883549, -2.6671805), (-2.4112113, -3.5660026), (-0.76239276, -4.6737156), (0.72881544, -3.0374305), (1.8504808, -2.9726355), (2.3999255, -2.3248758), (4.464444, -2.108619), (4.6226134, -0.69429535), (4.2615213, 0.8579904)];
    let pt = (2., 0.);
    println!("{:?}", point_in_poly(&poly, pt));
    println!("=====================");
    // println!("{:?}", point_in_poly(&tri, p2));
    // println!("=====================");
}