using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.Msagl.Core.DataStructures;
using Microsoft.Msagl.Core.Geometry;
using Microsoft.Msagl.Core.Geometry.Curves;
using Microsoft.Msagl.Core.Layout;
using Microsoft.Msagl.DebugHelpers;
using Microsoft.Msagl.Routing.Visibility;
using Point = Microsoft.Msagl.Core.Geometry.Point;
using SymmetricSegment = Microsoft.Msagl.Core.DataStructures.SymmetricTuple<Microsoft.Msagl.Core.Geometry.Point>;
//using Microsoft.Msagl.Miscellaneous.Rounded;

namespace Microsoft.Msagl.Miscellaneous.ConstrainedSkeleton
{
    internal class SteinerCdt
    {
        Dictionary<Point, int> _pointsToIndices = new Dictionary<Point, int>();
        readonly List<Point> _pointList = new List<Point>();
        readonly Set<SymmetricTuple<int>> _segments = new Set<SymmetricTuple<int>>();

        public Dictionary<int, VisibilityVertex> _outPoints = new Dictionary<int, VisibilityVertex>();
        public VisibilityGraph _visGraph;
        readonly IEnumerable<LgNodeInfo> _nodeInfos;
        Rectangle _boundingBox;
        readonly Random _random = new Random();
        public SteinerCdt(VisibilityGraph visGraph, IEnumerable<LgNodeInfo> nodeInfos)
        {
            _visGraph = visGraph;
            _nodeInfos = nodeInfos;
            //comment out by jyoti
            //MakeSureThatNodeBoundariesAreInVisGraph(nodeInfos);
        }

        void MakeSureThatNodeBoundariesAreInVisGraph(IEnumerable<LgNodeInfo> nodeInfos)
        {
            foreach (var nodeInfo in nodeInfos)
                foreach (var polypoint in nodeInfo.BoundaryOnLayer.PolylinePoints)
                    _visGraph.AddVertex(polypoint.Point);
        }

        public void SaveInputFilePoly(string path)
        {

            Console.WriteLine("\nInitializing Cdt input");

            IndexPoints();
            InitSegments();

            Debug.Assert(TopologyForCallingTriangleIsCorrect());
            Console.WriteLine("\nWriting Cdt input");

            using (var file = new StreamWriter(path))
            {
                WritePoints(file);
                WriteSegments(file);
                WriteHoles(file);
            }
        }

        void WriteHoles(StreamWriter file)
        {
            file.WriteLine("# holes");
            file.WriteLine(_nodeInfos.Count());
            int j = 0;
            foreach (var ni in _nodeInfos)
            {
                var c = ni.Center;
                file.WriteLine((j + 1) + " " + c.X + " " + c.Y);
                j++;
            }
        }

        void WriteSegments(StreamWriter file)
        {
            file.WriteLine("# segments");
            file.WriteLine(_segments.Count + " 0");
            int i = 1;
            foreach (var seg in _segments)
            {
                file.WriteLine(i + " " + (seg.A + 1) + " " + (seg.B + 1));
                i++;
            }
        }

        void WritePoints(StreamWriter file)
        {
            file.WriteLine("# vertices");
            file.WriteLine(_pointsToIndices.Count + " 2 0 0");
            foreach (var tuple in _pointsToIndices)
            {
                file.WriteLine(tuple.Value + 1 + " " + tuple.Key.X + " " + tuple.Key.Y);
            }
        }

        /*
        public void SaveInputToInputGeomtery()
        {
            CheckTopology();

            InitPoints();
            InitSegments();
            InputGeometry inputGeometry = new InputGeometry();
            file.WriteLine("# vertices");
            file.WriteLine(_pointIndices.Count + " 2 0 0");
            foreach (var tuple in _pointIndices)
            {
                file.WriteLine(tuple.Value + 1 + " " + tuple.Key.X + " " + tuple.Key.Y);
            }
            file.WriteLine("# segments");
            file.WriteLine(_segments.Count + " 0");
            int i = 1;
            foreach (var seg in _segments)
            {
                file.WriteLine(i + " " + (seg.Item1 + 1) + " " + (seg.Item2 + 1));
                i++;
            }

            file.WriteLine("# holes");
            //file.WriteLine("0");

            file.WriteLine(_holes.Count);
            for (int j = 0; j < _holes.Count; j++)-
            {
                file.WriteLine((j + 1) + " " + _holes[j].X + " " + _holes[j].Y);
            }
        }
        */

        public void LoadOutputFileNode(string path)
        {
            int oldPoints = _pointList.Count;
            using (var file = new StreamReader(path))
            {
                string line = file.ReadLine();
                if (line == null) throw new InvalidOperationException("unexpected end of file");
                Regex.Split(line, @"\s{2,}");

                int numVertices = Int32.Parse(line.Split(' ').First());

                for (int i = 0; i < numVertices; i++)
                {
                    line = file.ReadLine();
                    if (line == null) break;

                    line = line.TrimStart(' ');
                    var lineParsed = Regex.Split(line, @"\s{2,}");
                    int ind = Int32.Parse(lineParsed[0]) - 1;
                    if (ind < oldPoints)
                        _outPoints[ind] = _visGraph.FindVertex(_pointList[ind]);
                    else
                    {
                        double x = Double.Parse(lineParsed[1]);
                        double y = Double.Parse(lineParsed[2]);
                        _outPoints[ind] = _visGraph.AddVertex(new Point(x, y));
                    }
                }
            }
        }


        public void LoadOutputFileSides(string path)
        {
            _visGraph.ClearEdges();
            using (var file = new StreamReader(path))
            {
                var line = file.ReadLine();
                if (line == null) throw new Exception("unexpected end of file");
                line = line.TrimStart(' ');

                int numTriangles = Int32.Parse(line.Split(' ').First());

                for (int i = 0; i < numTriangles; i++)
                {
                    line = file.ReadLine();
                    if (line == null) break;

                    line = line.TrimStart(' ');
                    var lineParsed = Regex.Split(line, @"\s{2,}");
                    int id0 = Int32.Parse(lineParsed[1]) - 1;
                    int id1 = Int32.Parse(lineParsed[2]) - 1;
                    int id2 = Int32.Parse(lineParsed[3]) - 1;

                    var v0 = _outPoints[id0];
                    var v1 = _outPoints[id1];
                    var v2 = _outPoints[id2];
                    AddVisEdge(v0, v1);
                    AddVisEdge(v1, v2);
                    AddVisEdge(v2, v0);
                }
            }
        }

        public void AddVisEdge(VisibilityVertex v0, VisibilityVertex v1)
        {
            if (v0 != v1)
            {
                VisibilityGraph.AddEdge(v0, v1);
            }
            else
            {
                Console.WriteLine("avoiding creating a small visibility edge");
            }
        }

        void InitSegment(Point p1, Point p2)
        {
            int id0 = _pointsToIndices[p1];
            int id1 = _pointsToIndices[p2];
            _segments.Insert(new SymmetricTuple<int>(id0, id1));
        }

        void IndexPoints()
        {
            _pointsToIndices.Clear();
            IndexVisGraphVertices();
            IndexNodeInfos();
            CreateAndIndexBoundingBox();
        }

        void IndexNodeInfos()
        {
            foreach (var ni in _nodeInfos)
            {
                AddNodeBoundaryToPointIndices(ni);
            }
        }

        void IndexVisGraphVertices()
        {
            if (_visGraph == null) return;
            foreach (var v in _visGraph.Vertices())
            {
                _pointsToIndices[v.Point] = _pointsToIndices.Count;
                _pointList.Add(v.Point);
            }
        }

        void CreateAndIndexBoundingBox()
        {
            _boundingBox = Rectangle.CreateAnEmptyBox();
            foreach (var p in _pointsToIndices.Keys) _boundingBox.Add(p);
            _boundingBox.Pad(1);
            IndexAPoint(_boundingBox.LeftBottom);
            IndexAPoint(_boundingBox.RightBottom);
            IndexAPoint(_boundingBox.LeftTop);
            IndexAPoint(_boundingBox.RightTop);
            //SplineRouter.ShowVisGraph(_visGraph, null, new[] { _boundingBox.Perimeter() }, null);
        }

        void AddNodeBoundaryToPointIndices(LgNodeInfo ni)
        {
            foreach (var polylinePoint in ni.BoundaryOnLayer.PolylinePoints)
                IndexAPoint(polylinePoint.Point);
        }

        void IndexAPoint(Point p)
        {
            if (!_pointsToIndices.ContainsKey(p))
            {
                _pointsToIndices[p] = _pointsToIndices.Count;
                _pointList.Add(p);
                _visGraph.AddVertex(p);
            }
        }

        bool TopologyForCallingTriangleIsCorrect()
        {
            Point[] indexToPoints = new Point[_pointsToIndices.Count];
            foreach (var pp in _pointsToIndices)
            {
                indexToPoints[pp.Value] = pp.Key;
            }

            var tree =
                new RTree<Point>(_pointsToIndices.Keys.Select(p => new KeyValuePair<Rectangle, Point>(new Rectangle(p), p)));
            var badSegs = (from e in _segments let overlaps = GetPointsOverlappingSeg(e, tree, indexToPoints) where overlaps.Count > 2 select e).ToList();

// #if TEST_MSAGL
//             if (badSegs.Any())
//                 ShowInputSegments(badSegs, indexToPoints);
// #endif
            return !badSegs.Any();
        }

// #if TEST_MSAGL
//         private void ShowInputSegments(List<SymmetricTuple<int>> badSegs, Point[] indexToPoints) {
//             var l = new List<DebugCurve>();
//             foreach (var seg in _segments)
//             {
//                 var p1 = indexToPoints[seg.A];
//                 var p2 = indexToPoints[seg.B];
//                 var ls = new LineSegment(p1, p2);
//
//                 string color = badSegs.Contains(seg) ? "red" : "black";
//                 double width = badSegs.Contains(seg) ? 3 : 1;
//                 l.Add(new DebugCurve(100, width, color, ls));
//             }
//             //foreach (var p in indexToPoints)
//             //{
//             //    l.Add(new DebugCurve(200, 0.1, "black", CurveFactory.CreateCircle(0.1, p)));
//             //}
//             LayoutAlgorithmSettings.ShowDebugCurves(l.ToArray());
//         }
// #endif

        /*
                void AddSegsHandlingOverlaps(SymmetricTuple<int> seg, RTree<Point> tree, Point[] indexToPoints) {
                    var overlaps = GetPointsOverlappingSeg(seg, tree,indexToPoints);
                    if (overlaps.Count <= 2) {
                        _segments.Insert(seg);
                        return;
                    }
                    Point ep0 = indexToPoints[seg.A];
                    AddSegment(ep0, overlaps[1]);
                    AddSegment(overlaps[overlaps.Count - 2], indexToPoints[seg.B]);
                    if (overlaps.Count > 3) {
                        AddSegsHandlingOverlaps(new SymmetricTuple<int>(_pointIndices[overlaps[1]],_pointIndices[overlaps[overlaps.Count - 2]]), tree, indexToPoints);
                    }
                }
        */

        List<Point> GetPointsOverlappingSeg(SymmetricTuple<int> seg, RTree<Point> tree, Point[] indexToPoints)
        {
            Point p0 = indexToPoints[seg.A];
            Point p1 = indexToPoints[seg.B];
            var rect = new Rectangle(p0, p1);
            rect.Pad(1e-5);

            Point[] vts = tree.GetAllIntersecting(rect).ToArray();

            double t;
            var vtsOverlapping = vts.Where(p => Point.DistToLineSegment(p, p0, p1, out t) < 1e-5).ToList();

            vtsOverlapping = vtsOverlapping.OrderBy(p => (p - p0).Length).ToList();
            if (vtsOverlapping.Count > 2)
            {
                Console.WriteLine("overlapping points");
                foreach (var v in vtsOverlapping)
                    Console.WriteLine(v);
            }
            return vtsOverlapping;
        }

        void InitSegments()
        {
            _segments.Clear();
            InitSegsOfVisGraph();
            foreach (var lgNodeInfo in _nodeInfos)
                InitSegsOfPolyline(lgNodeInfo.BoundaryOnLayer);
            InitSegments(_boundingBox.LeftTop, _boundingBox.RightTop, _boundingBox.RightBottom, _boundingBox.LeftBottom);
        }

        void InitSegsOfPolyline(Polyline polyline)
        {
            var pp = polyline.StartPoint;
            int startId = _pointsToIndices[pp.Point];
            int id = startId;
            do
            {
                pp = pp.Next;
                if (pp == null) break;
                int nextId = _pointsToIndices[pp.Point];
                _segments.Insert(new SymmetricTuple<int>(id, nextId));
                id = nextId;
            } while (true);
            _segments.Insert(new SymmetricTuple<int>(id, startId));
        }

        void InitSegments(params Point[] pts)
        {
            for (int i = 0; i < pts.Length - 1; i++)
                InitSegment(pts[i], pts[i + 1]);

            InitSegment(pts[pts.Length - 1], pts[0]);
        }

        void InitSegsOfVisGraph()
        {
            if (_visGraph == null) return;
            foreach (var v in _visGraph.Vertices())
            {
                int vId = _pointsToIndices[v.Point];
                foreach (var e in v.OutEdges)
                    _segments.Insert(new SymmetricTuple<int>(vId, _pointsToIndices[e.Target.Point]));
            }
        }


        public void LaunchTriangleExe(string pathExe, string arguments)
        {
#if !SHARPKIT
            const string triangleMessage =
                "Cannot start Triangle.exe To build Triangle.exe, please open http://www.cs.cmu.edu/~quake/triangle.html and build it by following the instructions from the site. Copy Triange.exe to a directory in your PATH." +
                "Unfortunately we cannot distribute Triangle.exe because of the license restrictions.";
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                CreateNoWindow = false,
                UseShellExecute = false,
                FileName = pathExe,
                WindowStyle = ProcessWindowStyle.Hidden,
                Arguments = arguments
            };

            try
            {
                using (Process exeProcess = Process.Start(startInfo))
                {
                    if (exeProcess == null)
                    {
                        Console.WriteLine(triangleMessage);
                        Environment.Exit(1);
                    }
                    exeProcess.WaitForExit();
                    if (exeProcess.ExitCode != 0)
                        Environment.Exit(exeProcess.ExitCode);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(triangleMessage);
                Console.WriteLine("Exiting now.");
                Environment.Exit(1);
            }
#endif
        }

        internal void ReadTriangleOutputAndPopulateTheLevelVisibilityGraphFromTriangulation()
        {
            string outPath = Path.Combine(Path.GetTempPath(), "pointssegments" + _random.Next(10000));
            SaveInputFilePoly(outPath + ".poly");
            const string exePath = "triangle.exe";
            string arguments = outPath + ".poly -c -q10 -S100000000";
            LaunchTriangleExe(exePath, arguments);
            Console.WriteLine("loading output of triangle exe");
            LoadOutputFileNode(outPath + ".1.node");
            LoadOutputFileSides(outPath + ".1.ele");
            File.Delete(outPath + ".poly");
            File.Delete(outPath + ".1.node");
            File.Delete(outPath + ".1.ele");
            File.Delete(outPath + ".1.poly");
        }
    }
}