Value.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata.Ecma335;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;

namespace NewPaloAltoTB;

/// <summary>
/// Contains a value (result of an expression).  This includes the type, but no
/// modifiers like public or readonly/const.
/// </summary>
internal class Value {
    internal ValueType VType = ValueType.None;
    internal object? OValue;
    //private bool v;

    private static readonly Value _nullValue = new();
    internal static Value NullValue => _nullValue;
    internal Value(bool v) {
        VType = ValueType.Bool;
        OValue = v;
    }

    internal Value(short v) {
        VType = ValueType.Short;
        OValue = v;
    }

    internal Value(int v) {
        VType = ValueType.Int;
        OValue = v;
    }

    internal Value(double v) {
        VType = ValueType.Double;
        OValue = v;
    }

    internal Value(string v) {
        VType = ValueType.String;
        OValue = v;
    }

    internal Value() {
        VType = ValueType.None;
        OValue = null;
    }

    public Value CastAsBool() {
        switch (VType) {
            case ValueType.Bool: return this;
            case ValueType.None: return new(false);
            case ValueType.Short: return new(((short?)OValue ?? 0) != 0);
            case ValueType.Int: return new((((int?)OValue) ?? 0) != 0);
            case ValueType.Double: return new((((double?)OValue) ?? 0.0) != 0.0);
            case ValueType.String: //we are being pretty permissive here!  Should probably make a formal converter...
                var tmpStr = (((string?)OValue) ?? "0").ToUpper();
                if (tmpStr.StartsWith("TRUE")) return new(true);
                if (tmpStr.StartsWith("T")) return new(true);
                if (tmpStr.StartsWith("YES")) return new(true);
                if (tmpStr.StartsWith("Y")) return new(true);
                if (tmpStr.StartsWith("1")) return new(true);
                if (tmpStr.StartsWith("FALSE")) return new(false);
                if (tmpStr.StartsWith("F")) return new(false);
                if (tmpStr.StartsWith("NO")) return new(false);
                if (tmpStr.StartsWith("N")) return new(false);
                if (tmpStr.StartsWith("0")) return new(false);
                throw new ArgumentException($"Cannot cast \"{(string?)OValue}\" as a boolean value.");
            default:
                throw new ArgumentException(); //Cast from unknown type - would mean coding not complete
        }
    }
    public Value CastAsShort() {
        switch (VType) {
            case ValueType.Bool: return new((short)((bool)(OValue ?? false) ? 1 : 0));
            case ValueType.None: return new((short)0);
            case ValueType.Short: return this;
            case ValueType.Int:
                var tmpInt = ((int?)OValue) ?? 0;
                if ((tmpInt < short.MinValue) || (tmpInt > short.MaxValue)) throw new ArgumentOutOfRangeException();
                return new((short)tmpInt);
            case ValueType.Double:
                var tmpDbl = ((double?)OValue) ?? 0.0;
                if ((tmpDbl < short.MinValue) || (tmpDbl > short.MaxValue)) throw new ArgumentOutOfRangeException();
                return new((short)tmpDbl);
            case ValueType.String:
                var tmpStr = ((string?)OValue) ?? "0";
                short tmpShortParsed;
                if (short.TryParse(tmpStr, out tmpShortParsed)) {
                    return new(tmpShortParsed);    
                }
                throw new ArgumentException(); //TryParse() failed - not a valid number, out of range, or followed by garbage (non-ws) text
            default:
                throw new ArgumentException(); //Cast from unknown type - would mean coding not complete
        }
    }

    public Value CastAsInt() {
        switch (VType) {
            case ValueType.Bool: return new((int)((bool)(OValue ?? false) ? 1 : 0));
            case ValueType.None: return new((int)0);
            case ValueType.Short: return new Value((int)((short?)OValue ?? 0));
            case ValueType.Int: return this;
            case ValueType.Double:
                var tmpDbl = ((double?)OValue) ?? 0.0;
                if ((tmpDbl < int.MinValue) || (tmpDbl > int.MaxValue)) throw new ArgumentOutOfRangeException();
                return new((int)tmpDbl);
            case ValueType.String:
                var tmpStr = ((string?)OValue) ?? "0"; //odd, why is tmpStr a nullable string when (evenANullValue ?? "0") cannot evaluate to null?
                int tmpIntParsed;
                if (int.TryParse(tmpStr, out tmpIntParsed)) {
                    return new(tmpIntParsed);    
                }
                throw new ArgumentException(); //TryParse() failed - not a valid number, out of range, or followed by garbage (non-ws) text
            default:
                throw new ArgumentException(); //Cast from unknown type - would mean coding not complete
        }
    }

    public Value CastAsDouble() {
        switch (VType) {
            case ValueType.Bool: return new((double)((((bool?)OValue) ?? false) ? 1.0 : 0.0));
            case ValueType.None: return new((short)0);
            case ValueType.Short: return new( (double)(((short?)OValue) ?? 0));
            case ValueType.Int: return new( (double)(((int?)OValue) ?? 0));
            case ValueType.Double: return this;
            case ValueType.String:
                var tmpStr = ((string?)OValue) ?? "0";
                double tmpParsed;
                if (double.TryParse(tmpStr, out tmpParsed)) {
                    return new(tmpParsed);    
                }
                throw new ArgumentException($"Cannot convert {(string?)OValue} to a floating point number."); //TryParse() failed - not a valid number, out of range, or followed by garbage (non-ws) text
            default:
                throw new ArgumentException(); //Cast from unknown type - would mean coding not complete
        }
    }

    public Value CastAsString() {
        switch (VType) {
            case ValueType.Bool: return new((((bool?)OValue) ?? false) ? "True" : "False");
            case ValueType.None: return new("Nil");
            case ValueType.Short: return new($"{OValue}");
            case ValueType.Int: return new($"{OValue}");
            case ValueType.Double: return new($"{OValue}");
            case ValueType.String: return this;
            default:
                throw new ArgumentException(); //Cast from unknown type - would mean coding not complete
        }
    }

    /// <summary>
    /// Coerce operands to matching or compatible types
    /// (this could be long and messy)
    /// Generally, coerce both operands to the wider/higher precision type.
    /// </summary>
    /// <param name="a">'this' is the first operand</param>
    /// <param name="b">b is the second operand</param>
    /// <param name="operType">operType describes the required operation: addition, multiplication, etc.</param>
    /// <returns>true if successful</returns>
    /// <exception cref="NotImplementedException"></exception>
    private bool NormalizeTypes(Value b, OperationType operType) {
        Value a = this;
        switch (operType) {
            case OperationType.None:
                break;
            case OperationType.Compare:
                if (a.VType == ValueType.Int && a.VType == b.VType) return true;
                break;
            case OperationType.AddSubtract:
                if (a.VType == ValueType.Int && a.VType == b.VType) return true;
               break;
            case OperationType.MultiplyDivide:
                if (a.VType == ValueType.Int && a.VType == b.VType) return true;
                break;
            case OperationType.BooleanLogical:
                if (a.VType == ValueType.Bool && a.VType == b.VType) return true;
                break;
            case OperationType.BooleanBitwise:
                break;
            default:
                break;
        }
        throw new NotImplementedException();
    }

    internal Value LessThanOrEqualTo(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() <= b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() <= b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() <= b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(ShortValue() <= b.ShortValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) <= 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value LessThan(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() < b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() < b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() < b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(ShortValue() < b.ShortValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) < 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value GreaterThanOrEqualTo(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() >= b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() >= b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() >= b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(ShortValue() >= b.ShortValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) >= 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value GreaterThan(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() > b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() > b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() > b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(ShortValue() > b.ShortValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) > 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value EqualTo(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() == b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() == b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() == b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(BoolValue() == b.BoolValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) == 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }

    internal Value NotEqualTo(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() != b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() != b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() != b.DoubleValue());

            case (ValueType.Bool, ValueType.Bool): //just compare false and true as 0 and 1
                return new(BoolValue() != b.BoolValue());

            case (ValueType.String, ValueType.String): //just compare false and true as 0 and 1
                return new(string.Compare(StringValue(), b.StringValue()) != 0);
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value Add(Value b) {
        //throw new NotImplementedException();
        //many cases to handle...
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() + b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() + b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() + b.DoubleValue());
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value Subtract(Value b) {
        switch ((VType, b.VType)) {
            
            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() - b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() - b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() - b.DoubleValue());
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value Multiply(Value b) {
        switch ((VType, b.VType)) {

            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() * b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() * b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() * b.DoubleValue());
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");

        }
    }
    internal Value Divide(Value b) {
        switch ((VType, b.VType)) {

            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() / b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new(ShortValue() / b.ShortValue());

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() / b.DoubleValue());
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value Modulo(Value b) {
        switch ((VType, b.VType)) {

            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new(IntValue() % b.IntValue());

            case (ValueType.Short, ValueType.Short):
                return new((short)(ShortValue() % b.ShortValue()));

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(DoubleValue() % b.DoubleValue());
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value Exponential(Value b) {
        switch ((VType, b.VType)) {

            case (ValueType.Int, ValueType.Int):
            case (ValueType.Int, ValueType.Short):
            case (ValueType.Short, ValueType.Int):
                return new((int) Math.Pow(IntValue(), b.IntValue()));

            case (ValueType.Short, ValueType.Short):
                return new((short) Math.Pow(ShortValue(), b.ShortValue()));

            case (ValueType.Double, ValueType.Double):
            case (ValueType.Double, ValueType.Int):
            case (ValueType.Double, ValueType.Short):
            case (ValueType.Int, ValueType.Double):
            case (ValueType.Short, ValueType.Double):
                return new(Math.Pow(DoubleValue(), b.DoubleValue()));
            default:
                throw new RuntimeException($"Sorry, I don't know how to handle these types.");
        }
    }
    internal Value LogicalAnd(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value LogicalOr(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value LogicalNot() {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value LogicalXor(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value BitwiseAnd(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value BitwiseOr(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value BitwiseNot() {
        throw new NotImplementedException();
        //many cases to handle...
    }
    internal Value BitwiseXor(Value b) {
        throw new NotImplementedException();
        //many cases to handle...
    }

    internal Value NegativeValue() {
        switch (VType) {
            case ValueType.Short:
                return new(0 - this.ShortValue());
            case ValueType.Int:
                return new(0 - this.IntValue());
            case ValueType.Double:
                return new(0 - this.DoubleValue());
            //case ValueType.Bool:
            //case ValueType.String:
            //    throw new NotImplementedException();
            default:
                throw new NotImplementedException();
        }
    }

    internal bool IsZero() {
        switch (VType) {
            case ValueType.Bool:
            case ValueType.String:
                break; //should never be called for non-XmlSchemaNumericFacet types
            case ValueType.Int:
                return (int)OValue == 0;
            case ValueType.Double:
                return (double)OValue == 0.0;
            default:
                break;
        }
        throw new NotImplementedException();
    }

    //internal Value CoerceType(ValueType vType) {
    //    (ValueType from, ValueType to) typePair = (this.VType, vType);
    //    switch (typePair) {
    //        case (from: ValueType.Bool, to: ValueType.Bool):        return this;
    //        case (from: ValueType.Bool, to: ValueType.Short):       return new((short)(((bool)OValue!) ? 1 : 0));
    //        case (from: ValueType.Bool, to: ValueType.Int):         return new(((bool)OValue!) ? 1 : 0);
    //        case (from: ValueType.Bool, to: ValueType.Double):      return new(((bool)OValue!) ? 1.0 : 0.0); 
    //        case (from: ValueType.Bool, to: ValueType.String):      return new(((bool)OValue!) ? "True" : "False");

    //        case (from: ValueType.Short, to: ValueType.Bool):       return new(((short)OValue!) != 0);
    //        case (from: ValueType.Short, to: ValueType.Short):      return this;
    //        case (from: ValueType.Short, to: ValueType.Int):        return new((int)(short)OValue!);
    //        case (from: ValueType.Short, to: ValueType.Double):     return new((double)(short)OValue!);
    //        case (from: ValueType.Short, to: ValueType.String):     return new($"{(short)OValue!}");

    //        case (from: ValueType.Int, to: ValueType.Bool):         return new(((int)OValue!) != 0);
    //        case (from: ValueType.Int, to: ValueType.Short):        return CastAsShort();
    //        case (from: ValueType.Int, to: ValueType.Int):          return this;
    //        case (from: ValueType.Int, to: ValueType.Double):       
    //        case (from: ValueType.Int, to: ValueType.String):       

    //        case (from: ValueType.Double, to: ValueType.Bool):      
    //        case (from: ValueType.Double, to: ValueType.Short):     
    //        case (from: ValueType.Double, to: ValueType.Int):       
    //        case (from: ValueType.Double, to: ValueType.Double):    return this;
    //        case (from: ValueType.Double, to: ValueType.String):    

    //        case (from: ValueType.String, to: ValueType.Bool):      
    //        case (from: ValueType.String, to: ValueType.Short):     
    //        case (from: ValueType.String, to: ValueType.Int):       
    //        case (from: ValueType.String, to: ValueType.Double):    
    //        case (from: ValueType.String, to: ValueType.String):    return this;

    //        default:
    //            throw new RuntimeException($"Cannot implicitly convert type {VType} to {vType}.");
    //            break;
    //    }
    //}

    internal Value CoerceType(ValueType vType) {
        switch (vType) {
            case ValueType.Bool:   return CastAsBool();
            case ValueType.Short:  return CastAsShort();
            case ValueType.Int:    return CastAsInt();
            case ValueType.Double: return CastAsDouble();
            case ValueType.String: return CastAsString();
            default:
                throw new RuntimeException($"Cannot implicitly convert type {VType} to {vType}.");
        }
    }

    internal bool BoolValue() {
        var v = CoerceType(ValueType.Bool);
        return (bool)v.OValue!;
    }
    internal short ShortValue() {
        var v = CoerceType(ValueType.Short);
        return (short)v.OValue!;
    }
    internal int IntValue() {
        var v = CoerceType(ValueType.Int);
        return (int)v.OValue!;
    }
    internal double DoubleValue() {
        var v = CoerceType(ValueType.Double);
        return (double)v.OValue!;
    }
    internal string StringValue() {
        var v = CoerceType(ValueType.String);
        return (string)v.OValue!;
    }

    internal bool IsPositive() {
        return VType switch {
            ValueType.None => throw new NotImplementedException(),
            ValueType.Short => ((short?)(OValue ?? 0)) > 0,
            ValueType.Int => ((int?)(OValue ?? 0)) > 0,
            ValueType.Double => ((double?)(OValue ?? 0)) > 0,
            ValueType.Bool => throw new NotImplementedException(),
            ValueType.String => throw new NotImplementedException(),
            _ => throw new NotImplementedException(),
        };
    }
    internal bool IsNegative() { 
        return VType switch {
            ValueType.None => throw new NotImplementedException(),
            ValueType.Short => ((short?)(OValue ?? 0)) < 0,
            ValueType.Int => ((int?)(OValue ?? 0)) < 0,
            ValueType.Double => ((double?)(OValue ?? 0)) < 0,
            ValueType.Bool => throw new NotImplementedException(),
            ValueType.String => throw new NotImplementedException(),
            _ => throw new NotImplementedException(),
        };
    }
}