/*
    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

using System;
using System.Collections.Generic;
using System.Drawing;

namespace Contours {
    public class Test {
        class Exception: System.Exception { }

        public string name;
        
        public readonly Dictionary<string, List<List<List<Point>>>> input = new Dictionary<string, List<List<List<Point>>>>();
        public readonly Dictionary<string, List<List<List<Point>>>> output = new Dictionary<string, List<List<List<Point>>>>();
        public readonly Dictionary<string, bool> results = new Dictionary<string, bool>();
        public bool result = false;
        
        public static readonly List<Test> tests = new List<Test>();
        
        void check(string name, Shape shape) {
            if (!input.ContainsKey(name)) return;
            List<List<List<Point>>> contours = null;
            try {
                contours = shape.getContours();
            } catch(System.Exception) { }
            output.Add(name, contours);
            results.Add(name, compareContours(input[name], output[name]));
            if (!results[name]) result = false;
        }
        
        Shape tryCreateShape(List<List<List<Point>>> contours) {
            try {
                Shape shape = new Shape();
                shape.setContours(contours);
                return shape;
            } catch (System.Exception) {
                return null;
            }
        }

        Shape tryCombineShapes(Shape.CombinationMode mode, List<List<List<Point>>> a, List<List<List<Point>>> b) {
            try {
                Shape sa = new Shape();
                Shape sb = new Shape();
                sa.setContours(a);
                sb.setContours(b);
                return Shape.combine(mode, sa, sb);
            } catch (System.Exception) {
                return null;
            }
        }
                
        public bool run() {
            result = true;
            
            List<List<List<Point>>> a = null;
            List<List<List<Point>>> b = null;

            if (input.ContainsKey("badA")) a = input["badA"]; else
                if (input.ContainsKey("a")) a = input["a"];
            if (input.ContainsKey("badB")) b = input["badB"]; else
                if (input.ContainsKey("b")) b = input["b"];
            
            if (a != null)
                check("a", tryCreateShape(a));
            if (b != null)
                check("b", tryCreateShape(b));
                
            if (a != null && b != null) {
                check("add", tryCombineShapes(Shape.CombinationMode.Add, a, b));
                check("subtract", tryCombineShapes(Shape.CombinationMode.Subtract, a, b));
                check("intersection", tryCombineShapes(Shape.CombinationMode.Intersection, a, b));
                check("xor", tryCombineShapes(Shape.CombinationMode.Xor, a, b));
            }

            return result;
        }

        public static bool compareContours(List<Point> a, List<Point> b) {
            if (a == null || b == null) return false;
            if (a.Count == b.Count) {
                for(int offset = 0; offset < a.Count; ++offset) {
                    bool equal = true;
                    for(int i = 0; i < a.Count; ++i)
                        if (a[(i + offset)%a.Count] != b[i])
                            { equal = false; break; }
                    if (equal) return true;
                }
            }
            return false;
        }

        public static bool compareContours(List<List<Point>> a, List<List<Point>> b) {
            if (a == null || b == null) return false;
            if (a.Count != b.Count) return false;
            if (a.Count == 0) return true;
            if (!compareContours(a[0], b[0])) return false;
            bool[] compared = new bool[a.Count];
            for(int i = 1; i < a.Count; ++i) {
                bool equal = false;
                for(int j = 1; j < b.Count; ++j) {
                    if (!compared[j] && compareContours(a[i], b[j]))
                        { equal = true; compared[j] = true; break; }
                }
                if (!equal) return false;
            }
            return true;
        }

        public static bool compareContours(List<List<List<Point>>> a, List<List<List<Point>>> b) {
            if (a == null || b == null) return false;
            if (a.Count != b.Count) return false;
            bool[] compared = new bool[a.Count];
            for(int i = 0; i < a.Count; ++i) {
                bool equal = false;
                for(int j = 0; j < b.Count; ++j) {
                    if (!compared[j] && compareContours(a[i], b[j]))
                        { equal = true; compared[j] = true; break; }
                }
                if (!equal) return false;
            }
            return true;
        }
                
        class Loader {
            public string text;
            public int position = 0;
            
            void error() { throw new Exception(); }
            void assert(bool expr) { if (!expr) error(); }

            void skipSpaces() {
                while(position < text.Length && char.IsWhiteSpace(text[position])) ++position;
                if (position < text.Length && text.Substring(position, 2) == "/*") {
                    while(position < text.Length)
                        if (text.Substring(position, 2) == "*/")
                            { position += 2; break; } else ++position;
                    skipSpaces();
                }
            }
            
            int loadInt() {
                skipSpaces();
                int startPosition = position;
                while(position < text.Length && char.IsDigit(text[position])) ++position;
                assert(startPosition < position);
                return int.Parse(text.Substring(startPosition, position-startPosition));
            }

            string tryLoadKey(string key) {
                return tryLoadKey(new string[] { key });
            }

            string tryLoadKey(string key0, string key1) {
                return tryLoadKey(new string[] { key0, key1 });
            }

            string tryLoadKey(string[] keys) {
                skipSpaces();
                foreach(string key in keys)
                    if (text.Substring(position, key.Length) == key)
                        { position += key.Length; return key; }
                return null;
            }
            
            string loadKey(string key) {
                return loadKey(new string[] { key });
            }

            string loadKey(string key0, string key1) {
                return loadKey(new string[] { key0, key1 });
            }

            string loadKey(string[] keys) {
                string result = tryLoadKey(keys);
                assert(result != null);
                return result;
            }
            
            Point loadPoint() {
                loadKey("(");
                int x = loadInt();
                loadKey(",");
                int y = loadInt();
                loadKey(")");
                return new Point(x, y);
            }
            
            List<Point> loadPointList() {
                List<Point> list = new List<Point>();
                loadKey("(");
                if (tryLoadKey(")") == null) do {
                    list.Add(loadPoint());
                } while(loadKey(",", ")") == ",");
                return list;
            }
            
            List<List<Point>> loadPointListList() {
                List<List<Point>> list = new List<List<Point>>();
                loadKey("(");
                if (tryLoadKey(")") == null) do {
                    list.Add(loadPointList());
                } while(loadKey(",", ")") == ",");
                return list;
            }
            
            List<List<List<Point>>> loadPointListListList() {
                List<List<List<Point>>> list = new List<List<List<Point>>>();
                loadKey("(");
                if (tryLoadKey(")") == null) do {
                    list.Add(loadPointListList());
                } while(loadKey(",", ")") == ",");
                return list;
            }
            
            string loadFieldName() {
                skipSpaces();
                int startPosition = position;
                while(position < text.Length && char.IsLetterOrDigit(text[position])) ++position;
                assert(startPosition < position);
                return text.Substring(startPosition, position-startPosition);
            }

            string loadName() {
                string name = "";
                loadKey("(");
                while(text[position] != ')')
                    name += text[position++];
                ++position;
                return name.Trim();
            }

            Test loadTest() {
                Test test = new Test();
                loadKey("{");
                while(tryLoadKey("}") == null) {
                    string name = loadFieldName();
                    loadKey(":");
                    if (name == "name")
                        test.name = loadName();
                    else
                        test.input.Add(name, loadPointListListList());
                }
                return test;
            }

            public List<Test> loadTestListToEof() {
                List<Test> list = new List<Test>();
                while(true) {
                    skipSpaces();
                    if (position >= text.Length) break;
                    list.Add(loadTest());
                }
                return list;
            }
        };
        
        static void loadTests(string text) {
            Loader loader = new Loader();
            loader.text = text;
            tests.Clear();
            tests.AddRange(loader.loadTestListToEof());
        }
        
        public static void loadTestsFromFile(string filename) {
            loadTests(System.IO.File.ReadAllText(filename));
        }
        
        public static bool runAll() {
            bool result = true;
            foreach(Test test in tests)
                if (!test.run()) result = false;
            return result;
        }

        static string resultToString(string name, bool result) {
            return name + ": " + (result ? "+" : "FAILED") + "\n";
        }

        public static string makeReport() {
            string report = "";
            foreach(Test test in tests) {
                report += resultToString(test.name, test.result);
                foreach(KeyValuePair<string, bool> pair in test.results)
                    report += resultToString("    " + pair.Key, pair.Value);
            }
            return report;
        }
        
        public static void saveReport(string filename) {
            System.IO.File.WriteAllText(filename, makeReport());
        }
    }
}