using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using Autodesk.AutoCAD.Geometry;
using System.IO;
using System.Globalization;

namespace Praktikum
{
    class SpeichenStern
    {
        const int cTKValue = -1; // TK -1;
        const int cLeerValue = -1000; // -666 = Leer
        const int cUnbekannt = -2000; // Unbekannt

        ArrayList _alUmfangLinien = new ArrayList();
        private ArrayList _alKantenInSpeichen = new ArrayList();

        private ArrayList _alKantenPool = new ArrayList();
        private ArrayList _alSpeichenStrahlen = new ArrayList(); // Element 0 ist HauptPunkt Pos
        private ArrayList _alpnPoint;

        public SpeichenStern(ArrayList alpnPoints)
        {
            _alpnPoint = alpnPoints;

            for (int i = 0; i < alpnPoints.Count; i++)
            {
                PolyNode plMain = (PolyNode)alpnPoints[i];
                PolyNode plIncoming;
                PolyNode plOutcoming;

                if ((i + 1) == alpnPoints.Count)
                    plOutcoming = (PolyNode)alpnPoints[0];
                else
                    plOutcoming =(PolyNode)alpnPoints[i + 1];
                if ((i-1) < 0)
                    plIncoming = (PolyNode)alpnPoints[(alpnPoints.Count - 1)];
                else
                    plIncoming = (PolyNode)alpnPoints[i - 1];

                SpeichenSternStrahl spStrahl = new SpeichenSternStrahl(plIncoming, plOutcoming, plMain,i);

                _alSpeichenStrahlen.Add(spStrahl);
            }

            _alUmfangLinien = GetUmfang();

            for (int i = 0; i < _alUmfangLinien.Count; i++)
            {
                structLinien strTemp = (structLinien)(_alUmfangLinien[i]);

                SperrKante(strTemp.iAnfangsPunkt, strTemp.iEndPunkt, _alUmfangLinien.IndexOf(strTemp)+10000);

         
            }
            for (int i = 0; i < _alSpeichenStrahlen.Count; i++)
            {
                ((SpeichenSternStrahl)_alSpeichenStrahlen[i]).PrintCurrentSpeichenStrahl();
            }
            CalcPossibleLines();
        }

     

        private ArrayList GetUmfang()
        {
            ArrayList UmfangLinien = new ArrayList();
            for (int i = 0; i < _alpnPoint.Count; i++)
            {
                PolyNode pnCurrent=(PolyNode)_alpnPoint[i];
                PolyNode pnNext;
                structLinien TempLinien = new structLinien();

                if ((i + 1) == _alpnPoint.Count)
                    pnNext = ((PolyNode)_alpnPoint[0]);
                else
                    pnNext = ((PolyNode)_alpnPoint[i+1]);

                TempLinien.dLaenge = pnCurrent.Distance(pnNext);
                TempLinien.iAnfangsPunkt = pnCurrent.iNodeIndex;
                TempLinien.iEndPunkt = pnNext.iNodeIndex;
                UmfangLinien.Add(TempLinien);
            }
            return UmfangLinien;
        }

        public ArrayList GetAllPossibleLines()
        {
            return _alKantenPool;
        }
        private void CalcPossibleLines()
        {
            ArrayList alLinien = new ArrayList();

            int counter = 0;
            for (int i = 0; i < (_alpnPoint.Count); i++)
            {
                for (int j = i + 2; j < (_alpnPoint.Count - 1 + counter); j++)
                {
                    PolyNode pnPointEins = (PolyNode)_alpnPoint[i];
                    PolyNode pnPointZwei = (PolyNode)_alpnPoint[j];

                    structLinien strLinien = new structLinien();
                    strLinien.iAnfangsPunkt = pnPointEins.iNodeIndex;
                    strLinien.iEndPunkt = pnPointZwei.iNodeIndex;
                    strLinien.dLaenge = pnPointEins.Distance(pnPointZwei);
                    if (strLinien.dLaenge > 0) // Noch Entfernen
                        alLinien.Add(strLinien); //Noch Entfernen
                }
                if (i == 0)
                    counter++;
            }

          //  ArrayList alLinienSortiert = (ArrayList)SortLines(alLinien); // Noch Entfernen

         //   _alKantenPool = (ArrayList)LoescheKongruenz(_alpnPoint, alLinienSortiert); // Noch Entfernen
            _alKantenPool = (ArrayList)SortLines(alLinien); 
        }
        private ArrayList SortLines(ArrayList alLinien)
        {
            for (int i = (alLinien.Count - 1); i >= 0; i--)
                for (int j = 1; j <= i; j++)

                    if (((structLinien)alLinien[j - 1]).dLaenge < ((structLinien)alLinien[j]).dLaenge)
                    {
                        structLinien temp = (structLinien)alLinien[j - 1];
                        alLinien[j - 1] = alLinien[j];
                        alLinien[j] = temp;
                    }

            return alLinien;
        }

        private bool TryLine(structLinien strLinie,PolyNode pnNodeEins, PolyNode pnZwei)
        {
            double dWinkel = pnNodeEins.GetWinkelPoint(pnZwei);
            SpeichenSternStrahl alsssStrahl = (SpeichenSternStrahl)_alSpeichenStrahlen[pnNodeEins.iNodeIndex];

            SpeichenSternNode strNeuStrahlBegin = new SpeichenSternNode();
            strNeuStrahlBegin.Blockiert = _alKantenPool.IndexOf(strLinie);
            strNeuStrahlBegin.pnPunktPos = ((PolyNode)_alpnPoint[pnZwei.iNodeIndex]);

            strNeuStrahlBegin.dWinkel = ((SpeichenSternNode)alsssStrahl._alStrahlNodes[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlBegin.pnPunktPos);

            SpeichenSternNode strNeuStrahlEnd = new SpeichenSternNode();
            strNeuStrahlEnd.Blockiert = _alKantenPool.IndexOf(strLinie);
            strNeuStrahlEnd.pnPunktPos = ((PolyNode)_alpnPoint[pnNodeEins.iNodeIndex]);
            strNeuStrahlEnd.dWinkel = ((SpeichenSternNode)alsssStrahl._alStrahlNodes[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlEnd.pnPunktPos);

            SpeichenSternNode ssnElement;
            for (int i = 0; i < alsssStrahl._alStrahlNodes.Count; i++)
            {
                ssnElement = (SpeichenSternNode)alsssStrahl._alStrahlNodes[i];

                if (ssnElement.dWinkel > dWinkel)
                {
                    if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[i - 1]).Blockiert) == cLeerValue)
                        return true;
                    else if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[i - 1]).Blockiert) == cTKValue)
                        return false;
                        if (alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd))
                            return true;
                        else
                            return false;
                }
                else if (ssnElement.dWinkel == dWinkel)
                    if (ssnElement.Blockiert == cLeerValue)
                        return true;
                    else if (ssnElement.Blockiert == cTKValue)
                        return false;
                    else
                    { 
                        ArrayList alGesetzteKanten = alsssStrahl.GetGesetzteKanten();
                        for (int j = 0; j < alGesetzteKanten.Count; j++)
                        {
                            SpeichenSternNode Temp = (SpeichenSternNode)alGesetzteKanten[j];
                            if (Temp.dWinkel == dWinkel)
                            {
                                if (Temp.Blockiert == cLeerValue)
                                    return true;
                                else if (Temp.Blockiert == cTKValue)
                                    return false;
                            }

                        }
                        if (alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd))
                            return true;
                        else
                            return false;
                    }
            }

            if ((((SpeichenSternNode)alsssStrahl._alStrahlNodes[alsssStrahl._alStrahlNodes.Count - 1]).Blockiert) == cTKValue)
                return false;
            if (!alsssStrahl.PruefeDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd))
                return false;
            
            return true;
        }

        public bool TryToSetLinie(structLinien strLinie)
        {
            PolyNode pnAnfang = ((PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]);
            PolyNode pnEnde = ((PolyNode)_alpnPoint[strLinie.iEndPunkt]);

            if (!TryLine(strLinie, pnAnfang,pnEnde))
                return false;
            if (!TryLine(strLinie, pnEnde,pnAnfang))
                return false;

            if (PruefeKongurent(_alpnPoint,strLinie))
                return false;

            SperrKante(strLinie.iAnfangsPunkt, strLinie.iEndPunkt, _alKantenPool.IndexOf(strLinie));

            _alKantenInSpeichen.Add(strLinie);
            return true;
        }

        /*

        public bool TryToSetLinie(structLinien strLinie, bool bAddLine)
        {
            int iCounter = 0;
            PolyNode AnfangsNode = ((PolyNode)_alpnPoint[strLinie.iAnfangsPunkt]);
            PolyNode EndNode = ((PolyNode)_alpnPoint[strLinie.iEndPunkt]);
            
            double dWinkel = AnfangsNode.GetWinkelPoint(EndNode);
            SpeichenSternStrahl alsssAnfangsPunkt = (SpeichenSternStrahl)_alSpeichenStrahlen[strLinie.iAnfangsPunkt];

            bool bBlockiert;

            for (int i = 1; i < alsssAnfangsPunkt._alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i - 1]).Blockiert == cLeerValue)
                    bBlockiert = false;
                else
                    bBlockiert = true;

                if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).dWinkel >= dWinkel)
                    if (bBlockiert)
                        if (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).dWinkel == dWinkel)
                            if ((((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).Blockiert == cLeerValue) ||
                                (((SpeichenSternNode)alsssAnfangsPunkt._alStrahlNodes[i]).Blockiert == cTKValue))
                                break;
                            else
                          //  {
                          //      iCounter++;
                          //      break;
                         //   }
                         return false;
                        else
                            return false;
                    else
                        break;
            }

            dWinkel = EndNode.GetWinkelPoint(AnfangsNode);
            SpeichenSternStrahl alsssEckEndPunkt = (SpeichenSternStrahl)_alSpeichenStrahlen[strLinie.iEndPunkt];

            for (int i = 1; i < alsssEckEndPunkt._alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i - 1]).Blockiert == cLeerValue)
                    bBlockiert = false;
                else
                    bBlockiert = true;

                if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).dWinkel >= dWinkel)
                    if (bBlockiert)
                        if (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).dWinkel == dWinkel)
                            if ((((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).Blockiert == cLeerValue) ||
                                (((SpeichenSternNode)alsssEckEndPunkt._alStrahlNodes[i]).Blockiert == cTKValue))
                                break;
                            else
                          //  {
                         //       iCounter++;
                         //       break;
                         //   }
                         return false;
                        else
                            return false;
                    else
                        break;
            }
            if (iCounter == 2)
                return false;

            int iKantenPool;
            
            if (!bAddLine)
                iKantenPool = _alUmfangLinien.IndexOf(strLinie)+10000;
            else
                iKantenPool = _alKantenPool.IndexOf(strLinie);

                SperrKante(strLinie.iAnfangsPunkt, strLinie.iEndPunkt, iKantenPool);

            if (bAddLine)
            _alKantenInSpeichen.Add(strLinie);
            return true;
        }*/
        public ArrayList GetGesetzteLinien()
        {
            return _alKantenInSpeichen;
        }

        private void SperrKante(int iAnfangsEcke, int iEndEcke, int iKanteKantenPool)
        {
            for (int i = 0; i < _alSpeichenStrahlen.Count; i++)
                if ((i != iAnfangsEcke) && (i != iEndEcke))
                {
                    ArrayList alEckStrahl = ((SpeichenSternStrahl)_alSpeichenStrahlen[i])._alStrahlNodes;

                    SpeichenSternNode strNeuStrahlBegin = new SpeichenSternNode();
                    strNeuStrahlBegin.Blockiert = iKanteKantenPool;
                    strNeuStrahlBegin.pnPunktPos = ((PolyNode)_alpnPoint[iAnfangsEcke]);
              
                    strNeuStrahlBegin.dWinkel = ((SpeichenSternNode)alEckStrahl[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlBegin.pnPunktPos);

                    SpeichenSternNode strNeuStrahlEnd = new SpeichenSternNode();
                    strNeuStrahlEnd.Blockiert = iKanteKantenPool;
                    strNeuStrahlEnd.pnPunktPos = ((PolyNode)_alpnPoint[iEndEcke]);
                    strNeuStrahlEnd.dWinkel = ((SpeichenSternNode)alEckStrahl[0]).pnPunktPos.GetWinkelPoint(strNeuStrahlEnd.pnPunktPos); 
                   
                    if (strNeuStrahlEnd.dWinkel < strNeuStrahlBegin.dWinkel)
                    {
                        SpeichenSternNode Temp = strNeuStrahlBegin;
                        strNeuStrahlBegin = strNeuStrahlEnd;
                        strNeuStrahlEnd = Temp;
                    }

                    if ((strNeuStrahlEnd.dWinkel - strNeuStrahlBegin.dWinkel) > 180)
                    {
                        SpeichenSternNode Temp = strNeuStrahlBegin;
                        strNeuStrahlBegin = strNeuStrahlEnd;
                        strNeuStrahlEnd = Temp;
                    }
                    SpeichenSternStrahl sssStrahl = (SpeichenSternStrahl)_alSpeichenStrahlen[i];

                    strNeuStrahlEnd.Blockiert = cUnbekannt;
                    if ((2== i))
                        i = i;
                    if (sssStrahl.PruefeKorrigiereDoppelteBlockierung(strNeuStrahlBegin, strNeuStrahlEnd))
                    {
                        sssStrahl.AddValueWinkel(strNeuStrahlBegin);
                        sssStrahl.AddValueWinkel(strNeuStrahlEnd);
                        sssStrahl.SetSperrSektorenNeu(strNeuStrahlBegin, strNeuStrahlEnd);
                    }
                }
        }

        public void PrintStern()
        {
            for (int i = 0; i < _alSpeichenStrahlen.Count; i++)
                ((SpeichenSternStrahl)_alSpeichenStrahlen[i]).PrintCurrentSpeichenStrahl();
        }

     /*   private ArrayList LoescheKongruenz(ArrayList alpnEckPoint, ArrayList alLinien)
        {
            ArrayList alUmfang = new ArrayList();

            ArrayList alPossibleKongurent = new ArrayList();
            for (int i = 0; i < alpnEckPoint.Count; i++)
            {
                PolyNode pnEckPointEins = (PolyNode)alpnEckPoint[i];
                PolyNode pnEckPointZwei;
                if ((i + 1) < alpnEckPoint.Count)
                    pnEckPointZwei = (PolyNode)alpnEckPoint[i + 1];
                else
                    pnEckPointZwei = (PolyNode)alpnEckPoint[0];

                alUmfang.Add(pnEckPointEins.Distance(pnEckPointZwei));
            }

            for (int i = 0; i < alLinien.Count; i++)
                if (alUmfang.Contains((((structLinien)alLinien[i]).dLaenge)))
                    alPossibleKongurent.Add(alLinien[i]);

            for (int i = 0; i < alPossibleKongurent.Count; i++)
            {
                structLinien strLinie = (structLinien)alPossibleKongurent[i];

                PolyNode pnAnfang = (PolyNode)_alpnPoint[strLinie.iAnfangsPunkt];
                PolyNode pnEnde = (PolyNode)_alpnPoint[strLinie.iEndPunkt];

                Line2d Line = new Line2d(pnAnfang.p2DPoint, pnEnde.p2DPoint);

                for (int j = 0; j < _alpnPoint.Count; j++)
                {
                    PolyNode pnEckAnfang;
                    PolyNode pnEckEnde;

                    pnEckAnfang = ((PolyNode)_alpnPoint[j]);

                    if ((j + 1) == _alpnPoint.Count)
                        pnEckEnde = ((PolyNode)_alpnPoint[0]);
                    else
                        pnEckEnde = ((PolyNode)_alpnPoint[j + 1]);

                    Line2d LineUmfang = new Line2d(pnEckAnfang.p2DPoint, pnEckEnde.p2DPoint);
                    Line2d LineUmfang2 = new Line2d(pnEckEnde.p2DPoint, pnEckAnfang.p2DPoint);

                    if ((LineUmfang.IsEqualTo(Line)) || (LineUmfang2.IsEqualTo(Line)))
                    {
                        alLinien.Remove(alPossibleKongurent[i]);
                        alPossibleKongurent.RemoveAt(i);
                        i = i - 1;
                        break;
                    }
                }
            }
            return alLinien;
        }*/

        private bool PruefeKongurent(ArrayList alpnEckPoint, structLinien strLinien)
        {
            ArrayList alUmfang = new ArrayList();
       
            ArrayList alPossibleKongurent = new ArrayList();
            for (int i = 0; i < alpnEckPoint.Count; i++)
            {
                PolyNode pnEckPointEins = (PolyNode)alpnEckPoint[i];
                PolyNode pnEckPointZwei;
                if ((i + 1) < alpnEckPoint.Count)
                    pnEckPointZwei = (PolyNode)alpnEckPoint[i + 1];
                else
                    pnEckPointZwei = (PolyNode)alpnEckPoint[0];

                    alUmfang.Add(pnEckPointEins.Distance(pnEckPointZwei));
            }

            if (alUmfang.Contains((strLinien.dLaenge)))
                alPossibleKongurent.Add(strLinien);

            for(int i = 0; i < alPossibleKongurent.Count; i++)
            {
                structLinien strLinie = (structLinien)alPossibleKongurent[i];

                PolyNode pnAnfang = (PolyNode)_alpnPoint[strLinie.iAnfangsPunkt];
                PolyNode pnEnde = (PolyNode)_alpnPoint[strLinie.iEndPunkt];

                Line2d Line = new Line2d(pnAnfang.p2DPoint, pnEnde.p2DPoint);

                for(int j  = 0; j < _alpnPoint.Count;j++)
                {
                    PolyNode pnEckAnfang;
                    PolyNode pnEckEnde;

                    pnEckAnfang = ((PolyNode)_alpnPoint[j]);
                 
                    if ((j+1) == _alpnPoint.Count)
                        pnEckEnde = ((PolyNode)_alpnPoint[0]);
                    else
                        pnEckEnde = ((PolyNode)_alpnPoint[j + 1]);

                    Line2d LineUmfang = new Line2d(pnEckAnfang.p2DPoint, pnEckEnde.p2DPoint);
                    Line2d LineUmfang2 = new Line2d(pnEckEnde.p2DPoint, pnEckAnfang.p2DPoint);

                    if ((LineUmfang.IsEqualTo(Line)) || (LineUmfang2.IsEqualTo(Line)))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}