#include <iostream>
#include <vector>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/geometries/segment.hpp> 
#include <boost/geometry/geometries/point.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <iomanip>

#include <boost/geometry/algorithms/intersection.hpp>

//typedef boost::geometry::model::point Point;
//typedef boost::geometry::model::segment<Point> Segment;
namespace bg = boost::geometry;

struct Pointt
{
    float x;
    float y;
};

struct Line
{
    Pointt p1;
    Pointt p2;
    float m;
    float b;
};



float getM(Line line)
{
    float a = line.p2.y-line.p1.y;
    float b = line.p2.x-line.p1.x;
    float m = a/b;
    return m;
}

float getB(Line line)
{
    return -line.m*line.p1.x + line.p1.y;
}

bool pointOnLine(Pointt point, Line line)
{
    float y0;
    y0 = line.m * point.x + line.b;
    
    if (point.y == y0)
        return true;
    else
        return false;
}

bool pointInLineRange(Pointt point, Line line)
{
    if ((point.x >= line.p1.x && point.x <= line.p2.x) && (point.y >= line.p1.y && point.y <= line.p2.y))
        return true;
    else
        return false;
}

bool isIntersecting(Line line1, Line line2)
{
    Pointt intersectionPoint;
    float a;
    float b;
    a = line2.b - line1.b;
    b = line1.m - line2.m;
    intersectionPoint.x = a/b;
    intersectionPoint.y = line1.m * intersectionPoint.x + line1.b;
    std::cout<<"intersection point:"<<intersectionPoint.x<<" "<<intersectionPoint.y<<std::endl;
    
    return pointInLineRange(intersectionPoint, line1);
}



int main()
{
    std::cout << std::fixed;
    std::cout << std::setprecision(2);
    typedef bg::model::point<double, 2, bg::cs::cartesian> point_t;
    typedef bg::model::segment<point_t> segment_t;
    typedef bg::model::polygon<point_t> polygon_t;

    polygon_t poly1{
        {{-0.5, 1.0}, {1.0, 3.0}, {5.0, 6.0}, {6.0, 3.0}, {4.0, 0.0}, {-0.5, 1.0}},
        {}
    };
    polygon_t poly2{
        {{0.0, 0.0}, {0.0, 4.0}},
        {}
    };
    
    std::vector<point_t> output;
    boost::geometry::intersection(poly1, poly2, output);
    
    if (output.size() > 0)
    {
        std::cout<<"Number of Intersection points:"<<output.size()<<std::endl;
        /*double x, y;
        for (int i = 0; i < output.size(); i++)
        {
            x = bg::get<0>(output[i]);
            y = bg::get<1>(output[i]);
            std::cout<<"x:"<<x<<" y:"<<y<<std::endl;
        }*/
        //for(auto v = boost::begin(boost::geometry::exterior_ring(poly1)); v != boost::end(boost::geometry::exterior_ring(poly1)); ++v)
        
        std::vector<point_t> all_points;
        
        
        for (int v = 0; v < boost::geometry::exterior_ring(poly2).size(); v++)
        {
            //double x = bg::get<0>(*v);
            //double y = bg::get<1>(*v);
            point_t p = boost::geometry::exterior_ring(poly2)[v];
            //double x = bg::get<0>(p);
            //double y = bg::get<1>(p);
            all_points.push_back(p);
            //std::cout<<"x:"<<x<<" y:"<<y<<std::endl;
        }
        
        for (int v = 0; v < boost::geometry::exterior_ring(poly1).size() - 1; v++)
        {
            //double x = bg::get<0>(*v);
            //double y = bg::get<1>(*v);
            point_t p = boost::geometry::exterior_ring(poly1)[v];
            //double x = bg::get<0>(p);
            //double y = bg::get<1>(p);
            all_points.push_back(p);
            //std::cout<<"x:"<<x<<" y:"<<y<<std::endl;
        }
        
        float mat[all_points.size()][all_points.size()];
        
        for (int v1 = 0; v1 < all_points.size(); v1++)
        {
            point_t p1 = all_points[v1];
            double x1 = bg::get<0>(p1);
            double y1 = bg::get<1>(p1);
            for (int v2 = 0; v2 < all_points.size(); v2++)
            {
                point_t p2 = all_points[v2];
                double x2 = bg::get<0>(p2);
                double y2 = bg::get<1>(p2);
                polygon_t temp1{
                    {{x1, y1}, {x2, y2}},
                    {}
                };
                std::vector<point_t> tempoutput;
                boost::geometry::intersection(poly1, temp1, tempoutput);
                
                
                if (tempoutput.size() == 0)
                    mat[v1][v2] = bg::distance(p1, p2);
                else if(tempoutput.size() == 1)
                {
                    double x0 = bg::get<0>(tempoutput[0]);
                    double y0 = bg::get<1>(tempoutput[0]);
                    mat[v1][v2] = bg::distance(p1, p2);
                    if ((x0 == x1 && y0 == y1) || (x0 == x2 && y0 == y2))
                    {
                        mat[v1][v2] = bg::distance(p1, p2);
                        double a, b, slope, intercept, tempx1, tempx2, tempy1, tempy2;
                        a = y2 - y1;
                        b = x2 - x1;
                        slope = a/b;
                        intercept = -slope*x1 + y1;
                        tempx1 = -99;
                        tempx2 = 99;
                        tempy1 = slope*tempx1 + intercept;
                        tempy2 = slope*tempx2 + intercept;
                        polygon_t temp2{
                            {{tempx1, tempy1}, {tempx2, tempy2}},
                            {}
                        };
                        std::vector<point_t> tempoutput2;
                        boost::geometry::intersection(poly1, temp2, tempoutput2);
                    }
                    else
                        mat[v1][v2] = -2;
                }
                else if (tempoutput.size() == 2)
                {
                    //for (int k = 0; k < tempoutput2.size(); k++)
                    //{
                        double x3 = bg::get<0>(tempoutput[0]);
                        double y3 = bg::get<1>(tempoutput[0]);
                        if ((x3 == x1 && y3 == y1) || (x3 == x2 && y3 == y2))
                            mat[v1][v2] = bg::distance(p1, p2);
                        else
                            mat[v1][v2] = -5;
                        std::cout<<x3<<" "<<y3<<"   ";
                        
                    //}
                    std::cout<<std::endl;
                    //std::cout<<tempoutput2.size()<<std::endl;
                }
                else
                    mat[v1][v2] = -1;
                
                //std::cout<<x1<<","<<y1<<"   "<<x2<<","<<y2<<"      "<<tempoutput.size()<<std::endl;
            }
        }
        std::cout<<"MATRIX"<<std::endl;
        for (int j = 0; j < all_points.size(); j++)
        {
            for (int i = 0; i < all_points.size(); i++)
                std::cout<<mat[j][i]<<" ";
            std::cout<<std::endl;
        }
    }
    else
    {
        std::cout<<"doesn't intersect"<<std::endl;
    }
    
    //bool result = boost::geometry::intersects(seg1, seg2);
    //std::cout<<result;
    /*Point p1 = {1, 0};
    Point p2 = {4, 3};
    Line l1 = {p1, p2};
    l1.m = getM(l1);
    l1.b = getB(l1);
    
    Point p3 = {4, 0};
    Point p4 = {3, 1};
    Line l2 = {p3, p4};
    l2.m = getM(l2);
    l2.b = getB(l2);
    
    std::cout<<isIntersecting(l1, l2);*/
    return 0;
}