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

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

        private int _iSternNode;
        public bool bAusenkante = false; // 1 Mit dem Uhrzeigersinn // -1 Gegen dem Uhrzeigersinn

        public ArrayList _alStrahlNodes = new ArrayList();
        
        private ArrayList _AlleGesetztenKanten = new ArrayList();


        public SpeichenSternStrahl(PolyNode Incoming, PolyNode Outcoming, PolyNode MainNode, int iSternNode)
        {
            _iSternNode = iSternNode;
            SpeichenSternNode ssnStrahlNullPunkt = new SpeichenSternNode();
            ssnStrahlNullPunkt.dWinkel = dMainWinkelConst;
            ssnStrahlNullPunkt.pnPunktPos = MainNode;

            SpeichenSternNode ssnStrahlEingehenderPunkt = new SpeichenSternNode();
            SpeichenSternNode ssnStrahlAusgehenderPunkt = new SpeichenSternNode();
            ssnStrahlEingehenderPunkt.pnPunktPos = Incoming;
            ssnStrahlEingehenderPunkt.dWinkel = MainNode.GetWinkelPoint(Incoming);
            ssnStrahlAusgehenderPunkt.pnPunktPos = Outcoming;
            ssnStrahlAusgehenderPunkt.dWinkel = MainNode.GetWinkelPoint(Outcoming);

            if (ssnStrahlEingehenderPunkt.dWinkel < ssnStrahlAusgehenderPunkt.dWinkel)
            {
                SpeichenSternNode Temp = ssnStrahlEingehenderPunkt;
                ssnStrahlEingehenderPunkt = ssnStrahlAusgehenderPunkt;
                ssnStrahlAusgehenderPunkt = Temp;
            }

            bool bDrehen = false;
            
            if (ssnStrahlNullPunkt.pnPunktPos.iNodeIndex == 0)
            {
                if ((ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex) > (ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex))
                    bDrehen = false; // OK für -1
                else
                    bDrehen = true; // OK für -1

            }
            else
            {
                if ((ssnStrahlNullPunkt.pnPunktPos.iNodeIndex > ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex)
                    && (ssnStrahlNullPunkt.pnPunktPos.iNodeIndex > ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex))
                    bDrehen = false; // hier
                 
                else
                    if (ssnStrahlAusgehenderPunkt.pnPunktPos.iNodeIndex > ssnStrahlEingehenderPunkt.pnPunktPos.iNodeIndex)
                        bDrehen = true;
                    else
                        bDrehen = false; 
            }

            if (bDrehen == true )
            {
                SpeichenSternNode Temp = ssnStrahlEingehenderPunkt;
                ssnStrahlEingehenderPunkt = ssnStrahlAusgehenderPunkt;
                ssnStrahlAusgehenderPunkt = Temp;
            }

            ssnStrahlEingehenderPunkt.Blockiert = cTKValue;
            ssnStrahlAusgehenderPunkt.Blockiert = cLeerValue;

            if (ssnStrahlEingehenderPunkt.dWinkel > ssnStrahlAusgehenderPunkt.dWinkel)
            {
                ssnStrahlNullPunkt.Blockiert = cTKValue;
                bAusenkante = true;
            }
            else
                ssnStrahlNullPunkt.Blockiert = cLeerValue;


            if (ssnStrahlEingehenderPunkt.dWinkel == ssnStrahlNullPunkt.dWinkel)
                ssnStrahlNullPunkt.Blockiert = ssnStrahlEingehenderPunkt.Blockiert;
             
            AddValueWinkel(ssnStrahlNullPunkt);
            AddValueWinkel(ssnStrahlEingehenderPunkt);
            AddValueWinkel(ssnStrahlAusgehenderPunkt);
        }

        public ArrayList GetGesetzteKanten()
        {
            return _AlleGesetztenKanten;
        }

        public bool SetSperrSektorenNeu(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd)
        {
            int iAnfangIndex = -1;
            int iEndIndex = -1;
            for (int i = 0; i < _alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlBegin.dWinkel)
                {
                    iAnfangIndex = i;
                    break;
                }
            }
            for (int i = 0; i < _alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlEnd.dWinkel)
                {
                    iEndIndex = i;
                    break;
                }
            }
            if ((iAnfangIndex < 0) || (iEndIndex < 0))
                return false;

            int iBlockiertEnde = ((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert;

            if (ssnNeuStrahlEnd.pnPunktPos.p2DPoint.IsEqualTo(((SpeichenSternNode)_alStrahlNodes[0]).pnPunktPos.p2DPoint))
            {
                SpeichenSternNode Temp = new SpeichenSternNode();
                Temp.dWinkel = ssnNeuStrahlBegin.dWinkel+0.000000000001;
                Temp.pnPunktPos = ssnNeuStrahlBegin.pnPunktPos;

                for (int j = 0; j < _AlleGesetztenKanten.Count; j++)
                {
                    SpeichenSternNode aanAlleSub = (SpeichenSternNode)_AlleGesetztenKanten[j];
                    if (aanAlleSub.dWinkel == ssnNeuStrahlBegin.dWinkel)
                    {
                        Temp.Blockiert = aanAlleSub.Blockiert;
                        break;
                    }

                }







            //    Temp.Blockiert = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert;
                AddValueWinkel(Temp);
                iEndIndex = iAnfangIndex;
                iEndIndex++;
            }

            int iIndexCurrent = iAnfangIndex;

            do
            {
                iIndexCurrent++;
                if (iIndexCurrent == _alStrahlNodes.Count)
                    iIndexCurrent = 0;

                if (iEndIndex == iIndexCurrent)
                {
                    if (((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert == cUnbekannt)
                    {
                        int iFound = 0;
                        SpeichenSternNode Temp = new SpeichenSternNode();
                        for (int i = _AlleGesetztenKanten.Count - 1; i > 0; i--)
                            if (((SpeichenSternNode)_AlleGesetztenKanten[i]).dWinkel == ssnNeuStrahlBegin.dWinkel)
                            {
                                iFound++;
                                Temp =((SpeichenSternNode)_AlleGesetztenKanten[i]);
                                if (iFound == 2)
                                    break;
                            }

                        if (ssnNeuStrahlBegin.Blockiert == Temp.Blockiert)
                        {
                            Temp = new SpeichenSternNode();
                            Temp.Blockiert = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert;
                        }
                        

                        _AlleGesetztenKanten.Remove(ssnNeuStrahlEnd);
                        ssnNeuStrahlEnd.Blockiert = Temp.Blockiert;

                        _alStrahlNodes[iIndexCurrent] = ssnNeuStrahlEnd;
                        _AlleGesetztenKanten.Add(ssnNeuStrahlEnd); //
                    }
                    break;
                }
                SpeichenSternNode strStrahl = (SpeichenSternNode)_alStrahlNodes[iIndexCurrent];
                if (strStrahl.dWinkel == dMainWinkelConst)
                {
                    if (strStrahl.Blockiert != ssnNeuStrahlBegin.Blockiert)
                    {
                        strStrahl.Blockiert = ssnNeuStrahlBegin.Blockiert;

                        _alStrahlNodes[iIndexCurrent] = strStrahl;
                        _AlleGesetztenKanten.Add(strStrahl); //
                    }
                }
                else
                {
                    ssnNeuStrahlEnd.Blockiert = strStrahl.Blockiert;
                    iEndIndex--;
                    iIndexCurrent--;
                    _alStrahlNodes.Remove(strStrahl);
                }

            } while (true);

            return true;
        }


        public void AddValueWinkel(SpeichenSternNode ssnStrahl) // Erweitern um TR Korrektur
        {
            int iInsertPosition = 0;

            for (int i = 0; i < _alStrahlNodes.Count; i++)
            {
                SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i];
                if (ssnTemp.dWinkel < ssnStrahl.dWinkel)
                    iInsertPosition = i;
                else if (ssnTemp.dWinkel > ssnStrahl.dWinkel)
                {

                    if (iInsertPosition > 0)
                        iInsertPosition = i - 1;
                    break;
                }
                else
                {
                    if (ssnTemp.pnPunktPos.p2DPoint.IsEqualTo(ssnStrahl.pnPunktPos.p2DPoint))
                    {
                        if (ssnStrahl.Blockiert != cUnbekannt)
                        {
                            _alStrahlNodes[i] = ssnStrahl;
                            _AlleGesetztenKanten.Add(ssnStrahl);
                        }
                        iInsertPosition = (_alStrahlNodes.Count * -1) - 2;
                    }
                    //  break;
                }
            }
            if (iInsertPosition > -1)
            {
                if (_alStrahlNodes.Count == 0)
                    _alStrahlNodes.Insert(iInsertPosition, ssnStrahl);
                else
                    _alStrahlNodes.Insert(iInsertPosition + 1, ssnStrahl);
                _AlleGesetztenKanten.Add(ssnStrahl);
            }

        }

        /*
        public bool SetSperrSektorenNeu(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd)
        {
            int iAnfangIndex = -1;
            int iEndIndex = -1;
            for (int i = 0; i < _alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlBegin.dWinkel)
                {
                    iAnfangIndex = i;
                    break;
                }
            }
            for (int i = 0; i < _alStrahlNodes.Count; i++)
            {
                if (((SpeichenSternNode)_alStrahlNodes[i]).dWinkel == ssnNeuStrahlEnd.dWinkel)
                {
                    iEndIndex = i;
                    break;
                }
            }
            if ((iAnfangIndex < 0) || (iEndIndex < 0))
                return false;

            int iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex]).Blockiert;

            bool bLoeschen = true;

            if (iBlockiertAnfang != ssnNeuStrahlBegin.Blockiert)
            {
                bLoeschen = false;
                ssnNeuStrahlEnd.Blockiert = iBlockiertAnfang;
                _alStrahlNodes[iAnfangIndex] = ssnNeuStrahlBegin;
                _AlleGesetztenKanten.Add(ssnNeuStrahlBegin);
            }

            if (ssnNeuStrahlEnd.Blockiert == cUnbekannt)
            {
                if ((iAnfangIndex - 1) > -1)
                    iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[iAnfangIndex - 1]).Blockiert;
                else
                    iBlockiertAnfang = ((SpeichenSternNode)_alStrahlNodes[_alStrahlNodes.Count - 1]).Blockiert;

                ssnNeuStrahlEnd.Blockiert = iBlockiertAnfang;
            }

            int iIndexCurrent = iAnfangIndex;

            do
            {
                iIndexCurrent++;
                if (iIndexCurrent == _alStrahlNodes.Count)
                    iIndexCurrent = 0;

                if (iEndIndex == iIndexCurrent)
                {
                    if (((SpeichenSternNode)_alStrahlNodes[iEndIndex]).Blockiert == cUnbekannt)
                    {
                        _alStrahlNodes[iIndexCurrent] = ssnNeuStrahlEnd;
                        _AlleGesetztenKanten.Add(ssnNeuStrahlEnd); //
                    }
                    break;
                }
                SpeichenSternNode strStrahl = (SpeichenSternNode)_alStrahlNodes[iIndexCurrent];
                if (strStrahl.dWinkel == dMainWinkelConst)
                {
                    if (strStrahl.Blockiert != ssnNeuStrahlBegin.Blockiert)
                    {
                        strStrahl.Blockiert = ssnNeuStrahlBegin.Blockiert;

                        _alStrahlNodes[iIndexCurrent] = strStrahl;
                        _AlleGesetztenKanten.Add(strStrahl); //
                    }
                }
            } while (true);

            bool bGesperrt = false;
            if (bLoeschen)
                for (int i = 0; i < _alStrahlNodes.Count; i++)
                {
                    if (bGesperrt == false)
                        if ((((SpeichenSternNode)_alStrahlNodes[i]).Blockiert != cLeerValue) &&
                            (((SpeichenSternNode)_alStrahlNodes[i]).Blockiert != cTKValue))
                            bGesperrt = true;
                        else { }
                    else
                    {
                        if ((((SpeichenSternNode)_alStrahlNodes[i]).Blockiert == cLeerValue) ||
                            (((SpeichenSternNode)_alStrahlNodes[i]).Blockiert == cTKValue))
                            bGesperrt = false;
                        else
                        {
                         //   _alStrahlNodes.RemoveAt(i);
                          //  i = i - 1;
                        }
                    }
                }
            PrintCurrentSpeichenStrahl();
            return true;
        }
        */
        private bool IstDrauf(PolyNode Anfang, PolyNode Ende, PolyNode Endpunkt)
        {
            double LinieDist = Anfang.Distance(Ende);
            double ErsteDist = Anfang.Distance(Endpunkt);
            double ZweiteDist = Ende.Distance(Endpunkt);
            if (Math.Round((ErsteDist + ZweiteDist),6) == Math.Round(LinieDist,6))
                return true;
            else
                return false;
        }

        public bool PruefeKorrigiereDoppelteBlockierung(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd)
        {
            do
            {
                PolyNode SchnittLinieAnfang = new PolyNode();
                SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel, 0);

                PolyNode SchnittLinieEnde = new PolyNode();
                SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel, 0);

                SpeichenSternNode ssnGefundeneAnfang = new SpeichenSternNode();
                SpeichenSternNode ssnGefundeneEnde = new SpeichenSternNode();

                bool bSchneiden = false;

                for (int i = 1; i < _alStrahlNodes.Count; i++)
                {
                    SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i];
                    PolyNode pnGefundeneAnfang = new PolyNode();
                    PolyNode pnGefundeneEnde = new PolyNode();

                    if ((ssnTemp.Blockiert != cLeerValue) && (ssnTemp.Blockiert != cTKValue))
                    {
                        pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel, 0);
                        ssnGefundeneAnfang = ssnTemp;

                        if ((i + 1) == _alStrahlNodes.Count)
                        {
                            if (ssnTemp.Blockiert == (((SpeichenSternNode)_alStrahlNodes[0]).Blockiert) && (1 != i))
                                ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[1]);
                            else
                                ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[0]);
                        }
                        else
                            ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[i + 1]);

                        pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel, 0);

                    /*    if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel) 
                             SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0);
                        if (ssnTemp.dWinkel  >ssnGefundeneEnde.dWinkel)
                            pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0);
                        */
                        if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel)
                            SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0);
                        if (ssnTemp.dWinkel > ssnGefundeneEnde.dWinkel)
                            pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0);

                        if (SchnittLinieEnde.p2DPoint.X > 360)
                            if ((ssnGefundeneEnde.dWinkel < 90) && (ssnTemp.dWinkel < 90))
                            {
                                pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel + 360, 0);
                                pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0);
                            }

                        if (pnGefundeneEnde.p2DPoint.X > 360)
                            if ((ssnNeuStrahlBegin.dWinkel < 90) && (ssnNeuStrahlEnd.dWinkel < 90))
                            {
                                SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0);
                                SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel + 360, 0);
                            }
               

                        int iSchnitte = 0;

                        if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneAnfang))
                            if ((SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint) && (SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint))
                                iSchnitte++;
                        if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneEnde))
                            if ((SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint) && (SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint))
                                iSchnitte++;
                        if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieAnfang))
                            if ((pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint) && (pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint))
                                iSchnitte++;
                        if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieEnde))
                            if ((pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint) && (pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint))
                                iSchnitte++;

                        if (iSchnitte > 1)
                        {
                            bSchneiden = true;
                            break;
                        }
                        else if (Math.Round(pnGefundeneAnfang.p2DPoint.X, 5) == Math.Round(pnGefundeneEnde.p2DPoint.X, 5))
                        {
                            if (iSchnitte > 0)
                            {
                                bSchneiden = true;
                                break;
                            }
                        }
                    }
                }
                if (!bSchneiden)
                    return true;

                SpeichenSternNode ssnKnoten = (SpeichenSternNode)_alStrahlNodes[0];

                double dKnotenLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnKnoten.pnPunktPos), 5);
                double dAnfangLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlBegin.pnPunktPos), 5);
                double dEndeLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlEnd.pnPunktPos), 5);

                if (dKnotenLage < 0)
                    if ((dAnfangLage <= 0) && (dEndeLage <= 0))
                    { }
                    else
                        return false;
                else
                    if ((dAnfangLage >= 0) && (dEndeLage >= 0))
                    {
                        if ((dAnfangLage == 0) && (dEndeLage == 0) && (dKnotenLage == 0))
                            return false;
                    }
                    else
                        return false;


                for (int i = _AlleGesetztenKanten.Count - 1; i > 0; i--)
                {
                    SpeichenSternNode ssnTemp = (SpeichenSternNode)_AlleGesetztenKanten[i];
                    if (ssnTemp.dWinkel == ssnGefundeneAnfang.dWinkel)
                    {
                        ((SpeichenSternNode)_AlleGesetztenKanten[i]).Blockiert = cLeerValue;
                     //   _AlleGesetztenKanten.RemoveAt(i);

                        break;
                    }
                }
                for (int i = _alStrahlNodes.Count - 1; i > 0; i--)
                {
                    SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i];
                    if (ssnTemp.dWinkel == ssnGefundeneAnfang.dWinkel)
                    {
                        ((SpeichenSternNode)_alStrahlNodes[i]).Blockiert = cLeerValue;
                        break;
                    }
                }

            /*    ArrayList alUeberfluessige = (ArrayList)_alStrahlNodes.Clone();
                _alStrahlNodes.Clear();

                int iGesetzteKanten = _AlleGesetztenKanten.Count;
                ArrayList alTemp = (ArrayList)_AlleGesetztenKanten.Clone();
                _AlleGesetztenKanten.Clear();
                for (int i = 0; i < iGesetzteKanten; i++)
                {
                    SpeichenSternNode ssnTemp = (SpeichenSternNode)alTemp[i];
                    AddValueWinkel(ssnTemp);

                }*/
                SetKanten();

             /*   for (int i = 0; i < _alStrahlNodes.Count; i++)
                {
                    if (!(alUeberfluessige.Contains(_alStrahlNodes[i])))
                    {
                        _alStrahlNodes.RemoveAt(i);
                        i--;
                    }
                }*/

           //     return true;
            } while (true);
        }
 
        public bool PruefeDoppelteBlockierung(SpeichenSternNode ssnNeuStrahlBegin, SpeichenSternNode ssnNeuStrahlEnd)
        {
            PolyNode SchnittLinieAnfang = new PolyNode();
            SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel, 0);

            PolyNode SchnittLinieEnde = new PolyNode();
            SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel, 0);

            SpeichenSternNode ssnGefundeneAnfang = new SpeichenSternNode();
            SpeichenSternNode ssnGefundeneEnde = new SpeichenSternNode();

            bool bSchneiden = false;
       
            for (int i = 1; i < _alStrahlNodes.Count; i++)
            {
                SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i];
                PolyNode pnGefundeneAnfang = new PolyNode();
                PolyNode pnGefundeneEnde = new PolyNode();

                if ((ssnTemp.Blockiert != cLeerValue) && (ssnTemp.Blockiert != cTKValue))
                {
                    pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel, 0);
                    ssnGefundeneAnfang = ssnTemp;

                    if ((i + 1) == _alStrahlNodes.Count)
                    {
                        if (ssnTemp.Blockiert == (((SpeichenSternNode)_alStrahlNodes[0]).Blockiert) && (1 != i))
                            ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[1]);
                        else
                            ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[0]);
                    }
                    else
                        ssnGefundeneEnde = ((SpeichenSternNode)_alStrahlNodes[i + 1]);

                    pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel, 0);

                    if (ssnNeuStrahlBegin.dWinkel > ssnNeuStrahlEnd.dWinkel)
                        SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0);
                    if (ssnTemp.dWinkel > ssnGefundeneEnde.dWinkel)
                        pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0);

                    if (SchnittLinieEnde.p2DPoint.X > 360)
                        if ((ssnGefundeneEnde.dWinkel < 90) && (ssnTemp.dWinkel < 90))
                        {
                            pnGefundeneAnfang.p2DPoint = new Point2d(ssnTemp.dWinkel + 360, 0);
                            pnGefundeneEnde.p2DPoint = new Point2d(ssnGefundeneEnde.dWinkel + 360, 0);
                        }

                    if (pnGefundeneEnde.p2DPoint.X > 360)
                        if ((ssnNeuStrahlBegin.dWinkel < 90) && (ssnNeuStrahlEnd.dWinkel < 90))
                        {
                            SchnittLinieEnde.p2DPoint = new Point2d(ssnNeuStrahlEnd.dWinkel + 360, 0);
                            SchnittLinieAnfang.p2DPoint = new Point2d(ssnNeuStrahlBegin.dWinkel + 360, 0);
                        }

                    int iSchnitte = 0;

                    if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneAnfang))
                        if ((SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint) && (SchnittLinieEnde.p2DPoint != pnGefundeneAnfang.p2DPoint))
                            iSchnitte++;
                    if (IstDrauf(SchnittLinieAnfang, SchnittLinieEnde, pnGefundeneEnde))
                        if ((SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint) && (SchnittLinieAnfang.p2DPoint != pnGefundeneEnde.p2DPoint))
                            iSchnitte++;
                    if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieAnfang))
                        if ((pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint) && (pnGefundeneEnde.p2DPoint != SchnittLinieAnfang.p2DPoint))
                            iSchnitte++;
                    if (IstDrauf(pnGefundeneAnfang, pnGefundeneEnde, SchnittLinieEnde))
                        if ((pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint) && (pnGefundeneAnfang.p2DPoint != SchnittLinieEnde.p2DPoint))
                            iSchnitte++;

                    if (iSchnitte > 1)
                    {
                        bSchneiden = true;
                        break;
                    }
                    else if (Math.Round(pnGefundeneAnfang.p2DPoint.X, 5) == Math.Round(pnGefundeneEnde.p2DPoint.X, 5))
                    {
                        if (iSchnitte > 0)
                        {
                 
                            bSchneiden = true;
                            break;
                        }
                    }
                }
            }
            if (!bSchneiden)
                return true;

            SpeichenSternNode ssnKnoten = (SpeichenSternNode)_alStrahlNodes[0];

            double dKnotenLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnKnoten.pnPunktPos), 5);
            double dAnfangLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlBegin.pnPunktPos), 5);
            double dEndeLage = Math.Round(PunktLage(ssnGefundeneAnfang.pnPunktPos, ssnGefundeneEnde.pnPunktPos, ssnNeuStrahlEnd.pnPunktPos), 5);

            if (dKnotenLage < 0)
                if ((dAnfangLage <= 0) && (dEndeLage <= 0))
                { }
                else
                    return false;
            else
                if ((dAnfangLage >= 0) && (dEndeLage >= 0))
                {
                    if ((dAnfangLage == 0) && (dEndeLage == 0) && (dKnotenLage == 0))
                        return false;
                }
                else
                    return false;

            return true; // Keine Blockierung
        }

        private void SetKanten()
        {
            for (int i = 1; i < _alStrahlNodes.Count; i++)
            {
                SpeichenSternNode ssnVorher = (SpeichenSternNode)_alStrahlNodes[i-1];
                SpeichenSternNode ssnDerzeit = (SpeichenSternNode)_alStrahlNodes[i];

                if (ssnDerzeit.Blockiert == ssnVorher.Blockiert)
                {
                    _alStrahlNodes.RemoveAt(i);
                    for(int j = 0; j < _AlleGesetztenKanten.Count;j++)
                        if (((SpeichenSternNode)_AlleGesetztenKanten[j]).dWinkel == ssnDerzeit.dWinkel)
                        {
                            _AlleGesetztenKanten.RemoveAt(j);
                            break;
                        }
                    i--;
                }
            }
        }

        private double PunktLage(PolyNode AnfangLinie, PolyNode EndeLinie, PolyNode PunktPruefen)
        {
            Vector3d AnfangsPunkt = new Vector3d(AnfangLinie.p2DPoint.X, AnfangLinie.p2DPoint.Y, 1);
            Vector3d EndPunkt = new Vector3d(EndeLinie.p2DPoint.X, EndeLinie.p2DPoint.Y, 1);
            Vector3d Normale = AnfangsPunkt.CrossProduct(EndPunkt);
            Vector3d Punkt = new Vector3d(PunktPruefen.p2DPoint.X, PunktPruefen.p2DPoint.Y, 1);
            return Normale.DotProduct(Punkt);
        }


        public void AddValueWinkel(PolyNode pnNeuerPunkt)
        {
            PolyNode pnZentrum = (PolyNode)_alStrahlNodes[0];

            double dTempWinkel = pnZentrum.GetWinkelPoint(pnNeuerPunkt);

            SpeichenSternNode ssnStrahl = new SpeichenSternNode();

            ssnStrahl.pnPunktPos = pnNeuerPunkt;
            ssnStrahl.dWinkel = dTempWinkel;
            ssnStrahl.Blockiert = cLeerValue; //CalculateKonturkante(iSternEcke);
            AddValueWinkel(ssnStrahl);
        }

        public void PrintCurrentSpeichenStrahl()
        {
            Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            
            ed.WriteMessage("\n");
            ed.WriteMessage("Speichenstrahl: ");
            ed.WriteMessage(Convert.ToString(_iSternNode));
   
            for(int i = 0; i < _alStrahlNodes.Count;i++)
            {
                ed.WriteMessage("\n");
                SpeichenSternNode ssnTemp = (SpeichenSternNode)_alStrahlNodes[i];
                ed.WriteMessage("Index: ");
                ed.WriteMessage(Convert.ToString(ssnTemp.pnPunktPos.iNodeIndex));
                ed.WriteMessage(" Knoten: ");
                ed.WriteMessage(Convert.ToString(ssnTemp.pnPunktPos.iNodeIndex));
                ed.WriteMessage(" Winkel: ");
                ed.WriteMessage(Convert.ToString(ssnTemp.dWinkel));
                ed.WriteMessage(" Blockiert: ");

                if (ssnTemp.Blockiert == cLeerValue)
                    ed.WriteMessage("Leer");
                else if (ssnTemp.Blockiert == cTKValue)
                    ed.WriteMessage("TK");
                else if (ssnTemp.Blockiert >= 10000)
                {
                    ed.WriteMessage("K"+Convert.ToString(ssnTemp.Blockiert-10000));
                }
                else
                    ed.WriteMessage(Convert.ToString(ssnTemp.Blockiert));
            }
        }
    }
}