using MultiTerm.Core.Types;
using System.Text;

namespace MultiTerm.Core.Model;

/// <summary>
/// A string that contains symbols of multiple formats such as a standard character as well as hexadecimal or binary parts.
/// </summary>
public class MultiFormatString
{
    /// <summary>
    /// List of Symbols that are stored in this <see cref="MultiFormatString"/>
    /// </summary>
    public List<Tuple<FormatType, string>> FormatValuePairs { get; private set; } = new();

    /// <summary>
    /// Adds a single character to <see cref="FormatValuePairs"/>.
    /// </summary>
    /// <param name="format">format of the <paramref name="value"/></param>
    /// <param name="value">value of the symbol, must be convertible to an Unicode character</param>
    public void Add(FormatType format, string value)
    {
        // check if value is valid, if yes add to FormatValuePairs
        if (ValidateValue(format, value))
        {
            this.FormatValuePairs.Add(Tuple.Create(format, value));
        }
    }

    /// <summary>
    /// Removes a given amount of characters from the end of <see cref="FormatValuePairs"/>.
    /// </summary>
    /// <param name="amount">amount of characters to remove from the list, starting at the last item</param>
    /// <exception cref="ArgumentException">if amount <= 0</exception>
    public void Remove(int amount)
    {
        // guard amount <= 0
        if (amount <= 0) throw new ArgumentException($"{nameof(amount)} cannot be <= 0");

        // limit amount to maximum
        int listCount = this.FormatValuePairs.Count;
        if (amount > listCount)
        {
            amount = listCount;
        }

        // remove range
        this.FormatValuePairs.RemoveRange( (listCount - amount) , amount);
    }

    /// <summary>
    /// Converts the <see cref="MultiFormatString"/> to a string that only contains Unicode (UTF-16) characters.
    /// </summary>
    /// <returns>converted string</returns>
    public override string ToString()  // TODO Implement Unit Tests!
    {
        StringBuilder stringBuilder = new();
        string hexConversionCharacters = String.Empty, binaryConversionCharacters = String.Empty;

        // Internal function to check and finalize a Hexadecimal Conversion
        // parameter == null will force ending
        void finalizeHexConversion(Tuple<FormatType, string>? formatValuePair)
        {
            // hex conversion ongoing?
            if (String.IsNullOrEmpty(hexConversionCharacters) == false)
            {
                // ending conversion or reached limit of characters?
                if (formatValuePair == null ||
                    formatValuePair.Item1 != FormatType.Hexadecimal ||
                    hexConversionCharacters.Count() == 4)
                {
                    // finalize conversion
                    stringBuilder.Append(FromHexString(hexConversionCharacters));
                    // reset ongoing conversion
                    hexConversionCharacters = String.Empty;
                }
            }
        }

        // Internal function to check and finalize a Binary Conversion
        // parameter == null will force ending
        void finalizeBinaryConversion(Tuple<FormatType, string>? formatValuePair)
        {
            // binary conversion ongoing?
            if (String.IsNullOrEmpty(binaryConversionCharacters) == false)
            {
                // ending conversion or reached limit of characters?
                if (formatValuePair == null ||
                    formatValuePair.Item1 != FormatType.Binary ||
                    binaryConversionCharacters.Count() == 16)
                {
                    // finalize conversion
                    stringBuilder.Append(FromBinaryString(binaryConversionCharacters));
                    // reset ongoing conversion
                    binaryConversionCharacters = String.Empty;
                }
            }
        }

        // go through every character
        foreach (var formatValuePair in this.FormatValuePairs)
        {
            // finalize ongoing conversions if there are any
            finalizeHexConversion(formatValuePair);
            finalizeBinaryConversion(formatValuePair);

            switch (formatValuePair.Item1)  // switch by format
            {
                case FormatType.Character:
                    stringBuilder.Append(formatValuePair.Item2);
                    break;

                case FormatType.Hexadecimal:
                    hexConversionCharacters += formatValuePair.Item2;
                    break;

                case FormatType.Binary:
                    binaryConversionCharacters += formatValuePair.Item2;
                    break;

                default:
                    throw new NotImplementedException($"'{nameof(ToString)}()' does not implement conversion for format {formatValuePair.Item1}");
            }
        }

        // fully finalize after the loop, finish all unfinished conversions
        finalizeHexConversion(null);
        finalizeBinaryConversion(null);

        return stringBuilder.ToString();
    }

    /// <summary>
    /// Validates wether a certain <paramref name="value"/> is valid for the given <paramref name="format"/>.
    /// </summary>
    /// <returns>true if valid</returns>
    public static bool ValidateValue(FormatType format, string value)
    {
        // invalid if more than one character
        if(value.Count() > 1) 
        { return false; }

        // extract character
        var character = value.First();

        switch (format)
        {
            case FormatType.Character:
                return true;

            case FormatType.Hexadecimal:
                if (character >= '0' && character <= '9' ||
                    character >= 'A' && character <= 'F' ||
                    character >= 'a' && character <= 'f')
                { return true; }
                else
                { return false; };

            case FormatType.Binary:
                if (character == '0' || character == '1')
                { return true; }
                else
                { return false; };

            default:
                throw new NotImplementedException($"'{nameof(ValidateValue)}()' does not implement validation for format {format}");
        }
    }

    // from: https://stackoverflow.com/questions/724862/converting-from-hex-to-string
    // test with: returns: "Hello world" for "48656C6C6F20776F726C64"
    // see https://www.fileformat.info/info/charset/UTF-16/list.htm
    private static string FromHexString(string hexString)
    {
        // Added PadLeft so strings with one character do not get ignored
        string internalHexString = hexString.PadLeft(4, '0');
        var bytes = new byte[internalHexString.Length / 2];
        for (var i = 0; i < bytes.Length; i++)
        {
            bytes[i] = Convert.ToByte(internalHexString.Substring(i * 2, 2), 16);
        }

        return Encoding.BigEndianUnicode.GetString(bytes);
    }

    private static string FromBinaryString(string binaryString)
    {
        string internalBinaryString = binaryString.PadLeft(16, '0');
        var bytes = new byte[internalBinaryString.Length / 8];
        for (var i = 0; i < bytes.Length; i++)
        {
            bytes[i] = Convert.ToByte(internalBinaryString.Substring(i * 8, 8), 2);
        }

        return Encoding.BigEndianUnicode.GetString(bytes);
    }

}