using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TextEncrypter
{
    public partial class Main : Form
    {
        string sPlainText = null;
        string sCryptomethod = null;
        char[] cCryptoalphabet = null;
        int iChiffre = 0;

        public Main()
        {
            InitializeComponent();
            this.KeyPreview = true;
        }

        private void Main_Load(object sender, EventArgs e)
        {
            textBCryptoalphabet_TextChanged(sender, e);
            nUDCryptonumber.Maximum = cCryptoalphabet.Length;
        }

        private void Main_KeyPress(object sender, KeyPressEventArgs e)
        {
            switch (e.KeyChar)
            {
                case (char)Keys.Enter:
                    {
                        e.Handled = true; // gegen "Ding"-Ton

                        if (this.ActiveControl == textBDecryptnumber)
                        {
                            textBDecryptnumber.Text = Convert.ToString(cCryptoalphabet.Length - Convert.ToInt32(textBDecryptnumber.Text));
                        }
                        break;
                    }
            }
        }

        private void textBPlainText_TextChanged(object sender, EventArgs e)
        {
            try
            {
                sPlainText = textBPlainText.Text;
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void cBCryptomethod_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                sCryptomethod = cBCryptomethod.SelectedItem.ToString();

                switch (sCryptomethod)
                {
                    case "Caesar (low)":
                        {
                            nUDCryptonumber.Enabled = true;
                            textBDecryptnumber.Enabled = true;
                            chBDecrypt.Enabled = false;
                            break;
                        }
                    case "Caesar (high)":
                        {
                            nUDCryptonumber.Enabled = false;
                            textBDecryptnumber.Enabled = false;
                            chBDecrypt.Enabled = true;
                            break;
                        }
                    case "Atbasch":
                        {
                            nUDCryptonumber.Enabled = false;
                            textBDecryptnumber.Enabled = false;
                            chBDecrypt.Enabled = false;
                            break;
                        }
                    default:
                        {
                            MessageBox.Show("Keine gültige Verschlüsselungsmethode!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            break;
                        }
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void textBCryptoalphabet_TextChanged(object sender, EventArgs e)
        {
            try
            {
                cCryptoalphabet = textBCryptoalphabet.Text.ToCharArray();
                nUDCryptonumber.Maximum = cCryptoalphabet.Length;
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void btnEncode_Click(object sender, EventArgs e)
        {
            if (String.IsNullOrEmpty(textBCryptoalphabet.Text))
            {
                MessageBox.Show("Kein Verschlüsselungsalphabet angeführt.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            else if (cCryptoalphabet.Length < 25)
            {
                MessageBox.Show("Verschlüsselungsalphabet ist zu kurz. Mindestens 25 Zeichen.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            switch (sCryptomethod)
            {
                case "Caesar (low)":
                    {
                        textBEncodedText.Text = EncryptToCaesarLow(sPlainText, Convert.ToInt32(nUDCryptonumber.Value));
                        break;
                    }
                case "Caesar (high)":
                    {
                        textBEncodedText.Text = EncryptToCaesarHigh(sPlainText);
                        break;
                    }
                case "Atbasch":
                    {
                        textBEncodedText.Text = EncryptToAbtasch(sPlainText);
                        break;
                    }
                default:
                    {
                        MessageBox.Show("Keine gültige Verschlüsselungsmethode!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        break;
                    }
            }
        }

        #region Erweiterungsmethoden für die Verschlüsselung

        private int GetRestToCryptoalphabet(int actual)
        {
            return Math.Abs(cCryptoalphabet.Length - actual - iChiffre);
        }

        private int GetIndexOfArray(char search, char[] tosearch)
        {
            for (int i = 0; i < tosearch.Length; i++)
            {
                if (search == tosearch[i])
                {
                    return i;
                }
            }

            return -1;
        }

        private bool IsInValueRange(char search, char[] tosearch)
        {
            for (int i = 0; i < tosearch.Length; i++)
            {
                if (search == tosearch[i])
                {
                    return true;
                }
            }

            return false;
        }

        #endregion

        #region Verschlüsselungsmethoden

        private string EncryptToCaesarLow(string sText, int chiffre)
        {
            iChiffre = chiffre;
            string temp = null;

            for (int i = 0; i < sText.Length; i++)
            {
                if (IsInValueRange(sText[i], cCryptoalphabet))
                {
                    int index = GetIndexOfArray(sText[i], cCryptoalphabet);

                    if (index + iChiffre < cCryptoalphabet.Length)
                    {
                        temp += cCryptoalphabet[index + iChiffre];
                    }
                    else
                    {
                        int sum = GetRestToCryptoalphabet(index);
                        temp += cCryptoalphabet[sum];
                    }
                }
                else
                {
                    temp += sText[i];
                }
            }

            return temp;
        }

        private string EncryptToCaesarHigh(string sText)
        {
            string temp = null;

            if (!chBDecrypt.Checked)
            {
                iChiffre = 0;

                for (int i = 0; i < sText.Length; i++)
                {
                    iChiffre++;
                    if (IsInValueRange(sText[i], cCryptoalphabet))
                    {
                        int index = GetIndexOfArray(sText[i], cCryptoalphabet);

                        if (index + iChiffre < cCryptoalphabet.Length)
                        {
                            temp += cCryptoalphabet[index + iChiffre];
                        }
                        else
                        {
                            temp += cCryptoalphabet[GetRestToCryptoalphabet(index)];
                        }
                    }
                    else
                    {
                        temp += sText[i];
                    }
                }

                return temp;
            }
            else
            {
                // Umkehralgorithmus
                return temp;
            }
        }

        private string EncryptToAbtasch(string sText)
        {
            string temp = null;
            char[] cCryptoalphabetReversed = cCryptoalphabet.Reverse().ToArray();

            for (int i = 0; i < sText.Length; i++)
            {
                if (IsInValueRange(sText[i], cCryptoalphabetReversed))
                {
                    int index = GetIndexOfArray(sText[i], cCryptoalphabet);

                    temp += cCryptoalphabetReversed[index];
                }
                else
                {
                    temp += sText[i];
                }
            }
            
            return temp;
        }

        #endregion
    }
}