namespace Tecuceanu_Esprressione
{
    public partial class Form1 : Form
    {
        static string Trovaparentesi(string espressione)
        {
            int posizioneparentesiaperta = 0, posizioneparentesichiusa = 0;
            string contenutoparentesi = "";
            for (int i = espressione.Length - 1; i >= 0; i--)
            {
                if (espressione[i] == '(')
                {
                    posizioneparentesiaperta = i;
                    break;
                }
            }
            posizioneparentesichiusa = espressione.IndexOf(')', posizioneparentesiaperta);
            contenutoparentesi = espressione.Substring(posizioneparentesiaperta , posizioneparentesichiusa - posizioneparentesiaperta+1 );

            return contenutoparentesi;
        }
        public string Pdpm(string contenuto)
        {
            int operazioniprimarie = 0, operazionisecondarie = 0, operazioni = 0;
            for (int i = 0; i < contenuto.Length; i++)
            {

                if (contenuto[i] == '/' || contenuto[i] == '*')
                {
                    operazioniprimarie++;
                }
                if (contenuto[i] == '+' || contenuto[i] == '-')
                {
                    operazionisecondarie++;
                }
            }
            operazioni = operazioniprimarie + operazionisecondarie;
            int indicediviso = 0, indiceper = 0,indicepiù=0,indicemeno=0;
            int primadelsimbolo = 0, dopodelsimbolo = 0;
            double risultatodiviso = 0;
            string contenutoprima = "", contenutodopo = "", contrario = "", contenutod = "";
            char[] simboli = new char[] { '+', '*', '/', '-', '(', ')' };
            if (operazioni > 0)
            {
                if (operazioniprimarie > 0)
                {
                    for (int i = 0; i < contenuto.Length; i++)
                    {
                        if (contenuto[i] == '/')
                        {
                            indicediviso = i;
                            break;
                        }
                        if (contenuto[i] == '*')
                        {
                            indiceper = i;
                            break;
                        }
                    }
                    if (indicediviso == 0) { indicediviso = indiceper + 1; }
                    if (indiceper == 0) { indiceper = indicediviso + 1; }
                    if (indicediviso < indiceper)
                    {
                        for (int i = indicediviso - 1; i >= 0; i--)
                        {
                            for (int j = 0; j < 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    primadelsimbolo = i;
                                    break;
                                }
                                if (primadelsimbolo != 0)
                                {
                                    break;
                                }
                            }


                        }
                        for (int i = indicediviso + 1; i < contenuto.Length; i++)
                        {
                            for (int j = 0; j <= 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    dopodelsimbolo = i;
                                    break;
                                }
                            }
                            if (dopodelsimbolo != 0)
                            {
                                break;
                            }
                        }
                        for (int k = indicediviso + 1; k < dopodelsimbolo; k++)
                        {
                            contenutodopo = contenutodopo + contenuto[k];

                        }
                        if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
                        else
                        {
                            for (int i = contenutodopo.Length; i > 0; i--)

                            {
                                contenutod = contenutod + contenutoprima[i - 1];
                            }
                        }
                        for (int i = indicediviso - 1; i > primadelsimbolo; i--)
                        {
                            contenutoprima = contenutoprima + contenuto[i]
;
                        }

                        for (int i = contenutoprima.Length; i > 0; i--)
                        {
                            contrario = contrario + contenutoprima[i - 1];
                        }
                        contenutoprima = contrario;
                        contenutodopo = contenutod;
                        primadelsimbolo = Convert.ToInt32(contenutoprima);
                        dopodelsimbolo = Convert.ToInt32(contenutodopo);
                        risultatodiviso = Convert.ToDouble(primadelsimbolo) / Convert.ToDouble(dopodelsimbolo);
                        contrario = Convert.ToString(risultatodiviso);
                        return contrario;
                    }

                    else
                    {
                        for (int i = indiceper - 1; i >= 0; i--)
                        {
                            for (int j = 0; j < 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    primadelsimbolo = i;
                                    break;
                                }
                                if (primadelsimbolo != 0)
                                {
                                    break;
                                }
                            }


                        }
                        for (int i = indiceper + 1; i < contenuto.Length; i++)
                        {
                            for (int j = 0; j <= 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    dopodelsimbolo = i;
                                    break;
                                }
                            }
                            if (dopodelsimbolo != 0)
                            {
                                break;
                            }
                        }
                        for (int k = indiceper + 1; k < dopodelsimbolo; k++)
                        {
                            contenutodopo = contenutodopo + contenuto[k];

                        }
                        if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
                        else
                        {
                            for (int i = contenutodopo.Length; i > 0; i--)

                            {
                                contenutod = contenutod + contenutoprima[i - 1];
                            }
                        }
                        for (int i = indiceper - 1; i > primadelsimbolo; i--)
                        {
                            contenutoprima = contenutoprima + contenuto[i];
                        }

                        for (int i = contenutoprima.Length; i > 0; i--)
                        {
                            contrario = contrario + contenutoprima[i - 1];
                        }
                        contenutoprima = contrario;
                        contenutodopo = contenutod;
                        primadelsimbolo = Convert.ToInt32(contenutoprima);
                        dopodelsimbolo = Convert.ToInt32(contenutodopo);
                        risultatodiviso = Convert.ToDouble(primadelsimbolo) * Convert.ToDouble(dopodelsimbolo);
                        contrario = Convert.ToString(risultatodiviso);
                        return contrario;
                    }
                }
                //________________________________________________-------------------------------------________________
                else if (operazionisecondarie > 0)
                {
                    for (int i = 0; i < contenuto.Length; i++)
                    {
                        if (contenuto[i] == '+')
                        {
                            indicepiù = i;
                            break;
                        }
                        if (contenuto[i] == '-')
                        {
                            indicemeno = i;
                            break;
                        }
                    }
                    if (indicepiù == 0) { indicepiù = indicemeno + 1; }
                    if (indicemeno == 0) { indicemeno = indicepiù + 1; }
                    if (indicepiù < indicemeno)
                    {
                        for (int i = indicepiù - 1; i >= 0; i--)
                        {
                            for (int j = 0; j < 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    primadelsimbolo = i;
                                    break;
                                }
                                if (primadelsimbolo != 0)
                                {
                                    break;
                                }
                            }


                        }
                        for (int i = indicepiù + 1; i < contenuto.Length; i++)
                        {
                            for (int j = 0; j <= 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    dopodelsimbolo = i;
                                    break;
                                }
                            }
                            if (dopodelsimbolo != 0)
                            {
                                break;
                            }
                        }
                        for (int k = indicepiù + 1; k < dopodelsimbolo; k++)
                        {
                            contenutodopo = contenutodopo + contenuto[k];

                        }
                        if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
                        else
                        {
                            for (int i = contenutodopo.Length; i > 0; i--)

                            {
                                contenutod = contenutod + contenutoprima[i - 1];
                            }
                        }
                        for (int i = indicepiù - 1; i > primadelsimbolo; i--)
                        {
                            contenutoprima = contenutoprima + contenuto[i]
;
                        }

                        for (int i = contenutoprima.Length; i > 0; i--)
                        {
                            contrario = contrario + contenutoprima[i - 1];
                        }
                        contenutoprima = contrario;
                        contenutodopo = contenutod;
                        primadelsimbolo = Convert.ToInt32(contenutoprima);
                        dopodelsimbolo = Convert.ToInt32(contenutodopo);
                        risultatodiviso = Convert.ToDouble(primadelsimbolo) + Convert.ToDouble(dopodelsimbolo);
                        contrario = Convert.ToString(risultatodiviso);
                        return contrario;
                    }

                    else
                    {
                        for (int i = indicemeno - 1; i >= 0; i--)
                        {
                            for (int j = 0; j < 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    primadelsimbolo = i;
                                    break;
                                }
                                if (primadelsimbolo != 0)
                                {
                                    break;
                                }
                            }


                        }
                        for (int i = indicemeno + 1; i < contenuto.Length; i++)
                        {
                            for (int j = 0; j <= 5; j++)
                            {
                                if (contenuto[i] == simboli[j])
                                {
                                    dopodelsimbolo = i;
                                    break;
                                }
                            }
                            if (dopodelsimbolo != 0)
                            {
                                break;
                            }
                        }
                        for (int k = indicemeno + 1; k < dopodelsimbolo; k++)
                        {
                            contenutodopo = contenutodopo + contenuto[k];

                        }
                        if (contenutodopo.Length == 1) { contenutod = contenutodopo; }
                        else
                        {
                            for (int i = contenutodopo.Length; i > 0; i--)

                            {
                                contenutod = contenutod + contenutoprima[i - 1];
                            }
                        }
                        for (int i = indicemeno - 1; i > primadelsimbolo; i--)
                        {
                            contenutoprima = contenutoprima + contenuto[i];
                        }

                        for (int i = contenutoprima.Length; i > 0; i--)
                        {
                            contrario = contrario + contenutoprima[i - 1];
                        }
                        contenutoprima = contrario;
                        contenutodopo = contenutod;
                        primadelsimbolo = Convert.ToInt32(contenutoprima);
                        dopodelsimbolo = Convert.ToInt32(contenutodopo);
                        risultatodiviso = Convert.ToDouble(primadelsimbolo) - Convert.ToDouble(dopodelsimbolo);
                        contrario = Convert.ToString(risultatodiviso);
                        return contrario;
                    }
                }
            return contenutoprima;
            }
            string es = contenuto;
            return es;
        }

        public Form1(){
            InitializeComponent();
        }
        private void lbltitolo_Click(object sender, EventArgs e){
        }
        private void txtespressione_TextChanged(object sender, EventArgs e){
        }
        private void lblerrore_Click(object sender, EventArgs e){
        }
        private void lblrisultato_Click(object sender, EventArgs e){
        }
        private void btnrisolvi_Click(object sender, EventArgs e)
        {
            string apoggio = "";
            int contaparentesi = 0;
            string espressione = txtespressione.Text;
            apoggio = "(" + espressione + ")";
            espressione = apoggio;
            for (int i = 0; i < espressione.Length; i++)
            {
                if (espressione[i] == '+'|| espressione[i] == '-' || espressione[i] == '*' || espressione[i] == '/' )
                {
                    contaparentesi++;
                }
            }
            while (contaparentesi != 0)
            {
                espressione = apoggio;
                apoggio = espressione;
                string contenutoparentesi = "";
                string contenuto = Trovaparentesi(espressione);
                string risultatoperazione = Pdpm(contenuto);
                int posizioneparentesiaperta = 0, posizioneparentesichiusa = 0;
                for (int i = espressione.Length - 1; i > 0; i--)
                {
                    if (espressione[i] == '(')
                    {
                        posizioneparentesiaperta = i;
                        break;
                    }
                }
                posizioneparentesichiusa = espressione.IndexOf(')', posizioneparentesiaperta);
                contenutoparentesi = apoggio.Substring(posizioneparentesiaperta, posizioneparentesichiusa - posizioneparentesiaperta + 1);
                espressione = espressione.Remove(posizioneparentesiaperta, contenutoparentesi.Length);
                espressione = espressione.Insert(posizioneparentesiaperta, risultatoperazione);
                contaparentesi--;
            }
            lblerrore.Text = Convert.ToString(espressione);
        }
    }
}