using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using CaeMesh;
using CaeGlobals;

namespace FileInOut.Input
{
    [Serializable]
    public static class VolFileReader
    {
        // Methods                                                                                                                  
        static public FeMesh Read(string fileName, ElementsToImport elementsToImport)
        {
            return Read(fileName, elementsToImport, false);
        }
        static public FeMesh Read(string fileName, ElementsToImport elementsToImport, bool convertToSecondOrder)
        {
            if (fileName != null && File.Exists(fileName))
            {
                string[] lines =  CaeGlobals.Tools.ReadAllLines(fileName);
                //
                List<List<string>> dataSets = GetDataSets(lines);
                //
                int elementStartId = 1;
                Dictionary<int, FeNode> nodes = null;
                Dictionary<int, FeElement> elements = new Dictionary<int,FeElement>();
                // Geometry: itemId, allNodeIds
                Dictionary<int, HashSet<int>> surfaceIdNodeIds = new Dictionary<int, HashSet<int>>();
                Dictionary<int, HashSet<int>> edgeIdNodeIds = new Dictionary<int, HashSet<int>>();
                HashSet<int> vertexNodeIds = new HashSet<int>();
                //
                foreach (List<string> dataSet in dataSets)
                {
                    // Nodes
                    if (dataSet[0] == VolKeywords.points.ToString()) 
                    {
                        nodes = GetNodes(dataSet.ToArray());
                    }
                    // 3D Elements
                    else if (dataSet[0] == VolKeywords.volumeelements.ToString())           
                    {
                        AddVolumeElements(dataSet.ToArray(), elements, ref elementStartId);
                    }
                    // 2D Elements
                    else if (dataSet[0] == VolKeywords.surfaceelements.ToString() ||
                             dataSet[0] == VolKeywords.surfaceelementsuv.ToString())        
                    {
                        AddSurfaceElements(dataSet.ToArray(), elements, ref elementStartId, surfaceIdNodeIds);
                    }
                    // 1D Elements - always import
                    else if (dataSet[0] == VolKeywords.edgesegmentsgi2.ToString())          
                    {
                        AddLineElements(dataSet.ToArray(), elements, ref elementStartId, edgeIdNodeIds, vertexNodeIds);
                    }
                }
                //
                MergeEdgeElements(elements);
                //
                FeMesh mesh = new FeMesh(nodes, elements, MeshRepresentation.Mesh, null, null, convertToSecondOrder,
                                         ImportOptions.DetectEdges);
                //
                mesh.ConvertLineFeElementsToEdges(vertexNodeIds, true);
                //
                mesh.RenumberVisualizationSurfaces(surfaceIdNodeIds);
                mesh.RenumberVisualizationEdges(edgeIdNodeIds);
                //
                if (elementsToImport != ElementsToImport.All)
                {
                    if (!elementsToImport.HasFlag(ElementsToImport.Beam)) mesh.RemoveElementsByType<FeElement1D>();
                    if (!elementsToImport.HasFlag(ElementsToImport.Shell)) mesh.RemoveElementsByType<FeElement2D>();
                    if (!elementsToImport.HasFlag(ElementsToImport.Solid)) mesh.RemoveElementsByType<FeElement3D>();
                }
                //
                return mesh;
            }
            //
            return null;
        }
        //
        static private List<List<string>> GetDataSets(string[] lines)
        {
            int count = 0;
            List<string> dataSet = new List<string>();
            List<List<string>> dataSets = new List<List<string>>();

            HashSet<string> keywords = new HashSet<string>(Enum.GetNames(typeof(VolKeywords)));

            for (int i = 0; i < lines.Length; i++)
            {
                if (keywords.Contains(lines[i]))
                {
                    count++;
                    if (count == 1)
                    {
                        dataSets.Add(dataSet);
                        dataSet = new List<string>();
                        dataSet.Add(lines[i]);
                        count = 0;
                    }
                }
                else
                    dataSet.Add(lines[i]);
            }
            dataSets.Add(dataSet);

            return dataSets;
        }
        static private Dictionary<int, FeNode> GetNodes(string[] lines)
        {
            Dictionary<int, FeNode> nodes = new Dictionary<int, FeNode>();
            int id = 1;
            int N = int.Parse(lines[1]);
            FeNode node;
            string[] record1;
            string[] splitter = new string[] { " " };


            // line 0 is the line with the Keyword
            for (int i = 2; i < N + 2; i ++)
            {
                record1 = lines[i].Split(splitter, StringSplitOptions.RemoveEmptyEntries);

                node = new FeNode();
                node.Id = id;
                node.X = double.Parse(record1[0]);
                node.Y = double.Parse(record1[1]);
                node.Z = double.Parse(record1[2]);

                nodes.Add(id, node);
                id++;
            }

            return nodes;
        }
        static private void AddVolumeElements(string[] lines, Dictionary<int, FeElement> elements, ref int elementStartId)
        {
            int numNodes;
            int N = int.Parse(lines[1]);
            string[] record;
            string[] splitter = new string[] { " " };
            FeElement3D element = null;
            // Line 0 is the line with the Keyword
            for (int i = 2; i < N + 2; i++)
            {
                record = lines[i].Split(splitter, StringSplitOptions.RemoveEmptyEntries);
                numNodes = int.Parse(record[1]);
                switch (numNodes)
                {
                    case 4:
                        element = GetLinearTetraElement(elementStartId, record);
                        break;
                    case 6:
                        element = GetLinearWedgeElement(elementStartId, record);
                        break;
                    case 10:
                        element = GetParabolicTetraElement(elementStartId, record);
                        break;
                    default:
                        throw new NotSupportedException();
                }
                elements.Add(elementStartId, element);
                elementStartId++;
            }
        }
        static private void AddSurfaceElements(string[] lines, Dictionary<int, FeElement> elements, ref int startId,
                                               Dictionary<int, HashSet<int>> surfaceIdNodeIds)
        {
            //# surfnr    bcnr   domin  domout      np      p1      p2      p3  
            //surfaceelements                                                   
            //440                                                               
            // 2 1 1 0 3 46 47 57                                               
            //                                                                  
            // 2 1 1 0 6 2 1 407 6824 6825 6420                                 

            int numNodes;
            int N = int.Parse(lines[1]);
            int surfId;
            string[] record;
            string[] splitter = new string[] { " " };
            HashSet<int> surface;

            FeElement2D element = null;

            // line 0 is the line with the Keyword                              
            for (int i = 2; i < N + 2; i++)
            {
                record = lines[i].Split(splitter, StringSplitOptions.RemoveEmptyEntries);
                numNodes = int.Parse(record[4]);
                switch (numNodes)
                {
                    case 3:
                        element = GetLinearTriangleElement(startId, record);
                        break;
                    case 4:
                        element = GetLinearQuadrilateralElement(startId, record);
                        break;
                    case 6:
                        element = GetParabolicTriangleElement(startId, record);
                        break;
                    case 8:
                        element = GetParabolicQuadrilateralElement(startId, record);
                        break;
                    default:
                        throw new NotSupportedException();
                }
                elements.Add(element.Id, element);
                
                surfId = int.Parse(record[1]);
                if (surfaceIdNodeIds.TryGetValue(surfId, out surface)) surface.UnionWith(element.NodeIds);
                else surfaceIdNodeIds.Add(surfId, new HashSet<int>(element.NodeIds));   // create a copy!!!

                startId++;
            }
        }
        static private void AddLineElements(string[] lines, Dictionary<int, FeElement> elements, ref int startId,
                                            Dictionary<int, HashSet<int>> edges, HashSet<int> vertexNodeIds)
        {
            //# surfid  0   p1   p2   trignum1    trignum2   domin/surfnr1    domout/surfnr2   ednr1   dist1   ednr2   dist2  
            //edgesegmentsgi2                                                                                                 
            //170                                                                                                             
            //       1       0       1      10       -1       -1        0        0        7           -0        2          5.3
            //       1       0      10      11       -1       -1        0        0        8          5.3        2         10.6
            //       1       0      11      12       -1       -1        0        0        9         10.6        2         15.8
            //       1       0      12      13       -1       -1        0        0       10         15.8        2         21.1
            //     [0]     [1]     [2]     [3]      [4]      [5]      [6]      [7]      [8]          [9]     [10]         [11]
            int N = int.Parse(lines[1]);
            double value1;
            double value2;
            int edgeId;
            int surfceId;
            string[] record;
            string[] splitter = new string[] { " " };
            HashSet<int> edge;
            FeElement1D element;
            //
            double[] key1;
            double[] key2;
            HashSet<double[]> nodeIdValue;
            CaeGlobals.CompareDoubleArray comparer = new CaeGlobals.CompareDoubleArray();
            Dictionary<int, HashSet<double[]>> edgeIdNodeIdValue = new Dictionary<int, HashSet<double[]>>();
            // Line 0 is the line with the Keyword
            for (int i = 2; i < N + 2; i++)
            {
                record = lines[i].Split(splitter, StringSplitOptions.RemoveEmptyEntries);
                // Surface id
                surfceId = int.Parse(record[0]);
                // Edge id
                edgeId = int.Parse(record[10]);
                // Element
                element = GetLinearBeamElement(startId, record);
                elements.Add(startId, element);
                // Add nodes to an edge
                if (edges.TryGetValue(edgeId, out edge)) edge.UnionWith(element.NodeIds);
                else edges.Add(edgeId, new HashSet<int>(element.NodeIds)); // create a copy!!!
                // Collect node values
                value1 = double.Parse(record[9]);
                value2 = double.Parse(record[11]);
                key1 = new double[] { element.NodeIds[0], value1 };
                key2 = new double[] { element.NodeIds[1], value2 };
                //
                if (!edgeIdNodeIdValue.TryGetValue(edgeId, out nodeIdValue))
                {
                    nodeIdValue = new HashSet<double[]>(comparer);
                    edgeIdNodeIdValue.Add(edgeId, nodeIdValue);
                }
                nodeIdValue.Add(key1);
                nodeIdValue.Add(key2);
                //
                startId++;
            }
            // Get vertices
            double min;
            double max;
            int minId;
            int maxId;
            //
            foreach (var edgeEntry in edgeIdNodeIdValue)
            {
                min = double.MaxValue;
                max = -double.MaxValue;
                minId = -1;
                maxId = -1;
                foreach (var nodeEnty in edgeEntry.Value)
                {
                    if (nodeEnty[1] < min)
                    {
                        min = nodeEnty[1];
                        minId = (int)nodeEnty[0];
                    }
                    else if (nodeEnty[1] > max)
                    {
                        max = nodeEnty[1];
                        maxId = (int)nodeEnty[0];
                    }
                }
                vertexNodeIds.Add(minId);
                vertexNodeIds.Add(maxId);
            }
        }
        private static void MergeEdgeElements(Dictionary<int, FeElement> elements)
        {
            int[] key;
            FeElement[] elementsToRemove;
            List<FeElement> elementsToMerge;
            CompareIntArray comparer = new CompareIntArray();
            Dictionary<int[], List<FeElement>> nodeIdsElements = new Dictionary<int[], List<FeElement>>(comparer);
            foreach (var entry in elements)
            {
                if (entry.Value is FeElement1D edgeElement)
                {
                    key = edgeElement.NodeIds;
                    Array.Sort(key);
                    if (nodeIdsElements.TryGetValue(key, out elementsToMerge)) elementsToMerge.Add(edgeElement);
                    else nodeIdsElements.Add(key, new List<FeElement>() { edgeElement });
                }
            }
            //
            foreach (var entry in nodeIdsElements)
            {
                if (entry.Value.Count > 1)
                {
                    elementsToRemove = entry.Value.ToArray();
                    for (int i = 1; i < elementsToRemove.Length; i++)
                    {
                        elements.Remove(elementsToRemove[i].Id);
                    }
                }
            }
        }


        // Linear elements                                                                                                          
        static private LinearBeamElement GetLinearBeamElement(int id, string[] record)
        {
            int n = 2;
            int partId = int.Parse(record[0]);
            int[] nodes = new int[n];
            //
            for (int i = 0; i < n; i++) nodes[i] = int.Parse(record[i + 2]);
            //
            return new LinearBeamElement(id, -1, nodes);
        }
        static private LinearTriangleElement GetLinearTriangleElement(int id, string[] record)
        {
            int n = 3;
            int partId = int.Parse(record[1]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[5]);
            nodes[1] = int.Parse(record[6]);
            nodes[2] = int.Parse(record[7]);
            //
            return new LinearTriangleElement(id, -1, nodes);
        }
        static private LinearQuadrilateralElement GetLinearQuadrilateralElement(int id, string[] record)
        {
            int n = 4;
            int partId = int.Parse(record[1]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[5]);
            nodes[1] = int.Parse(record[6]);
            nodes[2] = int.Parse(record[7]);
            nodes[3] = int.Parse(record[8]);
            //
            return new LinearQuadrilateralElement(id, -1, nodes);
        }
        static private LinearTetraElement GetLinearTetraElement(int id, string[] record)
        {
            int n = 4;
            int partId = int.Parse(record[0]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[2]);
            nodes[1] = int.Parse(record[4]);    // swap 3 and 4
            nodes[2] = int.Parse(record[3]);
            nodes[3] = int.Parse(record[5]);
            //
            return new LinearTetraElement(id, partId, nodes);
        }
        static private LinearWedgeElement GetLinearWedgeElement(int id, string[] record)
        {
            int n = 6;
            int partId = int.Parse(record[0]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[2]);
            nodes[1] = int.Parse(record[4]);    // swap 3 and 4
            nodes[2] = int.Parse(record[3]);
            nodes[3] = int.Parse(record[5]);
            nodes[4] = int.Parse(record[7]);
            nodes[5] = int.Parse(record[6]);
            //
            return new LinearWedgeElement(id, partId, nodes);
        }


        // Parabolic elements                                                                                                       
        static private ParabolicTriangleElement GetParabolicTriangleElement(int id, string[] record)
        {
            int n = 6;
            int partId = int.Parse(record[1]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[5]);
            nodes[1] = int.Parse(record[6]);
            nodes[2] = int.Parse(record[7]);
            nodes[3] = int.Parse(record[10]);
            nodes[4] = int.Parse(record[8]);
            nodes[5] = int.Parse(record[9]);
            //
            return new ParabolicTriangleElement(id, -1, nodes);
        }
        static private ParabolicQuadrilateralElement GetParabolicQuadrilateralElement(int id, string[] record)
        {
            int n = 8;
            int partId = int.Parse(record[1]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[5]);
            nodes[1] = int.Parse(record[6]);
            nodes[2] = int.Parse(record[7]);
            nodes[3] = int.Parse(record[8]);
            nodes[4] = int.Parse(record[9]);
            nodes[5] = int.Parse(record[12]);
            nodes[6] = int.Parse(record[10]);
            nodes[7] = int.Parse(record[11]);
            //
            return new ParabolicQuadrilateralElement(id, -1, nodes);
        }
        static private ParabolicTetraElement GetParabolicTetraElement(int id, string[] record)
        {
            int n = 10;
            int partId = int.Parse(record[0]);
            int[] nodes = new int[n];
            //
            nodes[0] = int.Parse(record[2]);
            nodes[1] = int.Parse(record[4]);    // swap 3 and 4
            nodes[2] = int.Parse(record[3]);
            nodes[3] = int.Parse(record[5]);
            nodes[4] = int.Parse(record[7]);
            nodes[5] = int.Parse(record[9]);
            nodes[6] = int.Parse(record[6]);
            nodes[7] = int.Parse(record[8]);
            nodes[8] = int.Parse(record[11]);
            nodes[9] = int.Parse(record[10]);
            //
            return new ParabolicTetraElement(id, partId, nodes);
        }

    }
}