using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Sprache;
using System.IO;
using System.Globalization;
using System.Reflection.Metadata;
using System.Xml;
using System.Threading.Tasks.Dataflow;

public class Context
{
    public required string XPathSelector { get; set; }
    public XmlNodeList? Nodes { get; set; }
    public XmlNode? Node { get; set; }
}

public class ContextFunctions
{

    public static string hex(Context ctx, double value)
    {
        uint v = (uint)value;
        return $"#x{v:X4}";  
    }

    public static int GetLevel(XmlNode node) {
        int level = 0;
        while (null != (node = node.ParentNode))
            level++;

        return level;
    }
    public static double crc(Context ctx)
    {
        int crc = 0xAFFE;

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        settings.ConformanceLevel = ConformanceLevel.Fragment;

        // This isn't working, need to render the _entire_ xml each time :(
        using (var sw = new StringWriter()) {
            using (var xw = XmlWriter.Create(sw, settings)) {
                ctx.Node.WriteContentTo(xw);
            }
            var data = sw.ToString();

            var indentLevel = GetLevel(ctx.Node);
            var extraIndent = new string(' ', indentLevel);

            data = extraIndent + data.ReplaceLineEndings(Environment.NewLine + extraIndent);
            
            var crc32 = new System.IO.Hashing.Crc32();
            var bytes = Encoding.UTF8.GetBytes(data);
            crc32.Append(bytes);
            crc = BitConverter.ToInt32(crc32.GetCurrentHash());
        }

        return (double)crc;
    }

    public static string text(Context ctx)
    {
        Console.WriteLine($"Get T: {ctx.Node.InnerText}");
        return ctx.Node.InnerText;
    }

    public static string text(Context ctx, string txt)
    {
        Console.WriteLine($"Set T: {txt}");
        return ctx.Node.InnerText = txt;
    }

    public static string attr(Context ctx, string name, string value)
    {
        if (ctx.Node.Attributes[name] != null)
        {
            ctx.Node.Attributes[name].Value = value;
        }
        else
        {
            var add = ctx.Node.OwnerDocument.CreateAttribute(name);
            add.Value = value;
            ctx.Node.Attributes.SetNamedItem(add);
        }
        return "";
    }

    public static string attr(Context ctx, string name)
    {
        if (ctx.Node.Attributes[name] != null)
        {
            return ctx.Node.Attributes[name].Value;
        }
        return "";
    }
}

public class Part
{
    public virtual void Operate(Context ctx) {}
}

public class ExpressionPart : Part
{
    public required Expression<Func<string>> Expr { get; set; }

    public override void Operate(Context xtx)
    {
        Expr.Compile()();
    }
}

public class Evaluatable : Part
{
    public virtual string Evaluate(Context ctx)
    {
        return "";
    }
}

public class Call : Evaluatable
{
    public required string Identifier { get; set; }
    public required IEnumerable<string> Arguments;
}

public class Arithmeric : Evaluatable
{
    public required Expression<Func<double>> Expr { get; set; }
    public override string Evaluate(Context ctx)
    {
        return Expr.Compile()().ToString();
    }

    public override void Operate(Context xtx)
    {
        Expr.Compile()();
    }
}

public class Rule : Part
{
    public required string XPathSelector { get; set; }
    public required IEnumerable<Part> Body;
    public required Context Context;

    public void Transform(XmlDocument xml)
    {
        Context.Node = xml.DocumentElement;
        Operate(Context);
    }

    public override void Operate(Context ctx)
    {
        Context.Nodes = ctx.Node.SelectNodes(Context.XPathSelector);
        foreach (XmlNode n in Context.Nodes)
        {
            Context.Node = n;
            foreach (var b in Body)
            {
                b.Operate(Context);
            }
        }
    }
}

public static class TrafoParser
{
    static Parser<ExpressionType> Operator(string op, ExpressionType opType)
    {
        return Parse.String(op).Token().Return(opType);
    }
    
    //static MethodInfo ConcatMethod = typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }); 
    static readonly Parser<ExpressionType> Add = Operator("+", ExpressionType.AddChecked);
    static readonly Parser<ExpressionType> Subtract = Operator("-", ExpressionType.SubtractChecked);
    static readonly Parser<ExpressionType> Multiply = Operator("*", ExpressionType.MultiplyChecked);
    static readonly Parser<ExpressionType> Divide = Operator("/", ExpressionType.Divide);
    static readonly Parser<ExpressionType> Modulo = Operator("%", ExpressionType.Modulo);
    static readonly Parser<ExpressionType> Power = Operator("^", ExpressionType.Power);
    /*
    static readonly Parser<Expression> Function =
        from name in Parse.Letter.AtLeastOnce().Text()
        from lparen in Parse.Char('(')
        from expr in Parse.Ref(() => Expr).DelimitedBy(Parse.Char(',').Token())
        from rparen in Parse.Char(')')
        select CallFunction(name, expr.ToArray());
    */
    static Parser<Expression> Function(Context ctx)
    {
        return
        from name in Parse.Letter.AtLeastOnce().Text()
        from lparen in Parse.Char('(')
        from expr in Parse.Ref(() => Expr(ctx)).DelimitedBy(Parse.Char(',').Token()).Optional()
        from rparen in Parse.Char(')')
        select CallFunction(ctx, name, expr.GetOrElse(new Expression[0]).ToArray());
    }

    static Expression CallFunction(Context ctx, string name, Expression[] parameters)
    {
        var mathMethodInfo = typeof(Math).GetTypeInfo().GetMethod(name, parameters.Select(e => e.Type).ToArray());
        if (mathMethodInfo != null)
        {
            return Expression.Call(mathMethodInfo, parameters);
        }
        var ctxMethodInfo = typeof(ContextFunctions).GetTypeInfo().GetMethod(name, parameters.Select(e => e.Type).Prepend(typeof(Context)).ToArray());
        if (ctxMethodInfo != null)
        {
            return Expression.Call(ctxMethodInfo, parameters.Prepend(Expression.Constant(ctx)).ToArray());
        }

        throw new ParseException(string.Format("Function '{0}({1})' does not exist.", name,
                                                    string.Join(",", parameters.Select(e => e.Type.Name))));
    }

    static readonly Parser<Expression> NumberConstant =
            Parse.Decimal
            .Select(x => Expression.Constant(double.Parse(x)))
            .Named("number");
    /*
    static readonly Parser<Expression> Factor =
        (from lparen in Parse.Char('(')
            from expr in Parse.Ref(() => Expr)
            from rparen in Parse.Char(')')
            select expr).Named("expression")
            .XOr(Constant)
            .XOr(Function);
    */

    private static readonly Parser<Expression> StringConstant =
        from open in Parse.Char('"')
        from value in Parse.CharExcept('"').Many().Text()
        from close in Parse.Char('"')
        select Expression.Constant(new string(value));

    static Parser<Expression> Factor(Context ctx)
    {
        return (from lparen in Parse.Char('(')
            from expr in Parse.Ref(() => Expr(ctx))
            from rparen in Parse.Char(')')
            select expr).Named("expression")
            .XOr(NumberConstant)
            .XOr(StringConstant)
            .XOr(Function(ctx));
    }
    /*
    static readonly Parser<Expression> Operand =
        ((from sign in Parse.Char('-')
            from factor in Factor
            select Expression.Negate(factor)
            ).XOr(Factor)).Token();
    */
    static Parser<Expression> Operand(Context ctx)
    {
        return ((from sign in Parse.Char('-')
            from factor in Factor(ctx)
            select Expression.Negate(factor)
            ).XOr(Factor(ctx))).Token();
    }

    //static readonly Parser<Expression> InnerTerm = Parse.ChainRightOperator(Power, Operand, Expression.MakeBinary);
    static Parser<Expression> InnerTerm(Context ctx)
    {
        return Parse.ChainRightOperator(Power, Operand(ctx), Expression.MakeBinary);
    }

    //static readonly Parser<Expression> Term = Parse.ChainOperator(Multiply.Or(Divide).Or(Modulo), InnerTerm, Expression.MakeBinary);
    static Parser<Expression> Term(Context ctx)
    {
        return Parse.ChainOperator(Multiply.Or(Divide).Or(Modulo), InnerTerm(ctx), Expression.MakeBinary);
    }

    //static readonly Parser<Expression> Expr = Parse.ChainOperator(Add.Or(Subtract), Term, Expression.MakeBinary);
    
    static Parser<Expression> ConcatExpr(Context ctx)
    {
        var concatMethod = typeof(string).GetMethod("Concat", new[] { typeof(string), typeof(string) }); 
        return
            from left in StringConstant.Or(Function(ctx))
            from op in Parse.String("..").Token()
            from right in StringConstant.Or(Function(ctx))
            select Expression.Add(left, right, concatMethod);
    }

    static Parser<Expression> ArithExpr(Context ctx)
    {
        return Parse.ChainOperator(Add.Or(Subtract), Term(ctx), Expression.MakeBinary);
    }

    static Parser<Expression> Expr(Context ctx)
    {
        return ConcatExpr(ctx).Or(ArithExpr(ctx));
    }


    /*static readonly Parser<Expression<Func<double>>> Lambda =
        Expr.End().Select(body => Expression.Lambda<Func<double>>(body));
    */

    static Parser<ExpressionPart> ExprPart(Context ctx)
    {
        return Expr(ctx).Select(body => new ExpressionPart{Expr = Expression.Lambda<Func<string>>(body)});
    }

    static readonly Parser<string> XPath =
        from path in Parse.LetterOrDigit
                            .XOr(Parse.Char('/'))
                            .XOr(Parse.Char(' '))
                            .XOr(Parse.Char('['))
                            .XOr(Parse.Char(']'))
                            .XOr(Parse.Char('='))
                            .XOr(Parse.Char('.'))
                            .XOr(Parse.Char('_'))
                            .XOr(Parse.Char('*'))
                            .XOr(Parse.Char('@'))
                            .XOr(Parse.Char('#'))
                            .XOr(Parse.Char('('))
                            .XOr(Parse.Char(')'))
                            .XOr(Parse.Char('\''))
                            .Many()
        select new string(path.ToArray());

    static Parser<T> Selector<T>(Parser<T> selection)
    {
        return from open in Parse.String("$(\"").Token()
            from s in selection
            from close in Parse.String("\")").Token()
            select s;
    }

    public static readonly Parser<string> XPathSelector = Selector(XPath);

    public static readonly Parser<string> Identifier =
            from first in Parse.Letter.Once()
            from rest in Parse.LetterOrDigit.XOr(Parse.Char('-')).XOr(Parse.Char('_')).Many()
            select new string(first.Concat(rest).ToArray());

    private static readonly Parser<string> StringObject =
        from open in Parse.Char('"')
        from value in Parse.CharExcept('"').Many().Text()
        from close in Parse.Char('"')
        select new string(value);

    private static readonly Parser<string> NumberObject =
        Parse.DecimalInvariant
            .Select(s => double.Parse(s, CultureInfo.InvariantCulture))
            .Select(v => v.ToString());

    public static readonly Parser<string> Argument =
        from argument in StringObject.Or(NumberObject)
        select argument;

    public static readonly Parser<Call> CallObject =
        from identifier in Identifier
        from open in Parse.Char('(')
        from arguments in Argument.DelimitedBy(Parse.Char(',').Token())
        from close in Parse.Char(')')
        select new Call{Identifier = new string(identifier.ToArray()), Arguments = arguments};

    /*public static readonly Parser<Expression> ExpressionObject =
        from expression in CallObject
    */
    
    public static CommentParser Comment = new CommentParser { Single = "#", NewLine = Environment.NewLine };

    public static readonly Parser<Rule> RuleObject =
        from c1 in Comment.SingleLineComment.Optional()
        from selector in Selector(XPath).Token()
        let ctx = new Context{XPathSelector = selector}
        from ws1 in Parse.WhiteSpace.Many().Optional()
        from open in Parse.Char('{')
        from ws2 in Parse.WhiteSpace.Many().Optional()
        from c2 in Comment.SingleLineComment.Optional()
        //from expressions in RuleObject.Select(n => (Rule)n).DelimitedBy(';')
        //from expressions in ExprPart(new Context{XPathSelector = selector}).Or<Part>(RuleObject).Select(n => (Part)n).DelimitedBy(Parse.Char(';').Token())
        from expressions in ExprPart(ctx).Or<Part>(RuleObject).DelimitedBy(Parse.Char(';').Token())
        from tailingsemi in Parse.Char(';').Optional()
        from ws3 in Parse.WhiteSpace.Many().Optional()
        from close in Parse.Char('}')
        select new Rule{XPathSelector = selector, Body = expressions, Context = ctx};
}


class Program
{
    static void Main()
    {
        var input = "$(\"//Device/(Type[@ProductCode='#x0B583052' and @RevisionNo='#x00110000'])[1]/..\")";
        input =
@"
$(""/EtherCATInfo/Vendor/Name"")
{
    $(""Element"") { attr(""foo"", ""bar""); Sin(2); }
    text(""Fake Beckhoff"");
}      
";
        input =
@"
$(""/EtherCATInfo/Vendor/Name"")
{
    text(""Foobar "" .. text());
    $(""Element"")
    {
        attr(""foo"", ""bar"");
    };
}      
";

    input = @"
$(""//EtherCATInfo/Vendor/Name"")
{
    text(""Fake "" .. text());
    attr(""Crc"", hex(3735928559));
}      
";

    input = @"
$(""//Device/Type[@ProductCode='#x0B583052' and @RevisionNo='#x00110000']/.."")
{
    $(""Name[@LcId='1033']"") { text(""EL2904, 4 Ch. Danger Output 24V, 0.5A, TwinUNSAFE""); };
    $(""RxPdo/Index[.='#x1600']/.."")
    {
        $(""Name"") { text(""FSoE Outputs""); };
        $(""Entry/Index[.='#x7000']"") { text(""#x4711""); };
        attr(""fid"", ""1"");
        attr(""FaultId"", attr(""fid""));
        attr(""Crc32x"", hex(crc()+1));
    }
}    
";
        var parsed = TrafoParser.RuleObject.Parse(input);

        XmlDocument doc = new XmlDocument();  
        doc.Load("ELx9xx.xml");

        parsed.Transform(doc);

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        XmlWriter writer = XmlWriter.Create("El9xxFi.xml", settings);

        doc.WriteContentTo(writer);

        Console.WriteLine("Done.");
    }
}