using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace Iteratively
{
    class ItlyVerifier
    {
        public static readonly string UsageString = "Usage: itly_verifier.dll --instanceName name1 --instanceName name2 <file-path> [<file-path-2> ...]";
        public static readonly string FileLocation = "itly/c-sharp/ItlyVerifier.cs";
        public static readonly string NameItlyNamespace = "Iteratively";
        public static readonly string NameItlyTrackMethod = "Track";

        static void Main(string[] args)
        {
            var allReferences = new List<ItlyReference>();
            var allErrors = new List<VerifierError>();
            try
            {
                if (args.Length > 0)
                {
                    var ampliInstanceNames = new List<string>();
                    for (int i = 0; i < args.Length; i++)
                    {
                        if (args[i] == "--instanceName")
                        {
                            ampliInstanceNames.Add(args[i+1]);
                            i++;
                            continue;
                        }

                        var filePath = args[i];
                        try
                        {
                            var fileContents = File.ReadAllText(filePath);

                            // WARNING: This doesn't throw parsing errors
                            // WARNING: instead need to check Diagnostic flags
                            SyntaxTree tree = CSharpSyntaxTree.ParseText(fileContents);
                            var root = (CompilationUnitSyntax)tree.GetRoot();

                            // Check for parsing errors
                            if (root.ContainsSkippedText || root.ContainsDiagnostics)
                            {
                                var diagnostics = root.GetDiagnostics().ToList().ConvertAll<String>(
                                    (d) => Regex.Replace(d.ToString(), "\"", "\\\"")
                                );
                                allErrors.Add(new VerifierError(filePath, diagnostics));
                            }

                            var walker = new ItlyReferenceWalker(filePath, ampliInstanceNames);
                            walker.Visit(root);

                            allReferences.AddRange(walker.References);
                        }
                        catch (Exception ex)
                        {
                            // Add to Error list for output to Verifier
                            allErrors.Add(new VerifierError(ex.Message, filePath));
                        }
                    }
                }
                else
                {
                    // No file path, display usage
                    allErrors.Add(new VerifierError(
                        FileLocation,
                        $"Invalid arguments. No file path(s) provided. {UsageString}"
                    ));
                }
            }
            catch (Exception ex)
            {
                allErrors.Add(new VerifierError(FileLocation, "Unhandled exception. " + ex.Message));
            }

            // Output JSON to console
            Console.WriteLine(JsonHelper.ToJson(MapOutput(allReferences, allErrors)));
        }

        private static Dictionary<string, object> MapOutput(List<ItlyReference> references, List<VerifierError> errors)
        {
            return new Dictionary<string, object>()
            {
                ["errors"] = errors.GroupBy(x => x.Location)
                    .ToDictionary(
                        x => x.Key,
                        x => x.ToList<VerifierError>()
                          .ConvertAll(e => e.Errors.ToList<object>())[0] as object
                    ),
                ["references"] = references
                    .GroupBy(x => x.FilePath)
                    .ToDictionary(
                        x => x.Key,
                        x => x.ToList<ItlyReference>().ConvertAll(r =>
                        {
                            var dict = r.ToDict();
                            dict.Remove("filePath");
                            return dict as object;
                        }) as object
                    )
            };
        }
    }

    class VerifierError : IToDict
    {
        public string Location;
        public List<string> Errors;
        public VerifierError(string location, string error)
        {
            Location = location;
            Errors = new List<string> (new string[] { error });
        }

        public VerifierError(string location, List<string> errors)
        {
            Location = location;
            Errors = errors;
        }

        public Dictionary<string, object> ToDict()
        {
            return new Dictionary<string, object>()
            {
                ["location"] = this.Location,
                ["errors"] = this.Errors.ToList<object>() as object,
            };
        }

        public override string ToString() {
            return JsonHelper.ToJson(this.ToDict());
        }
    }

    class ItlyReference : IToDict
    {
        public string FilePath;
        public string Name;
        public int Row;
        public int Column;
        public ItlyReference(string filePath, string name, int row, int column)
        {
            FilePath = filePath;
            Name = name;
            Row = row;
            Column = column;
        }


        public Dictionary<string, object> ToDict()
        {
            return new Dictionary<string, object>()
            {
                ["filePath"] = this.FilePath,
                ["name"] = this.Name,
                ["row"] = this.Row,
                ["column"] = this.Column,
            };
        }

        public override string ToString() {
            return JsonHelper.ToJson(this.ToDict());
        }
    }

    class FileResults : IToDict
    {
        public string FilePath;
        public List<ItlyReference> References;
        public FileResults(string filePath, List<ItlyReference> references)
        {
            FilePath = filePath;
            References = references;
        }

        public Dictionary<string, object> ToDict()
        {
            return new Dictionary<string, object>()
            {
                ["filePath"] = this.FilePath,
                ["references"] = this.References
            };
        }

        public override string ToString() {
            return JsonHelper.ToJson(this.ToDict());
        }
    }

    class ItlyReferenceWalker : CSharpSyntaxWalker
    {
        private readonly string FilePath;
        public readonly List<ItlyReference> References;
        private readonly List<string> AmpliInstanceNames;

        public ItlyReferenceWalker(string filePath, List<string> ampliInstanceNames)
        {
            FilePath = filePath;
            References = new List<ItlyReference>();
            AmpliInstanceNames = ampliInstanceNames;
        }

        public override void VisitUsingDirective(UsingDirectiveSyntax node)
        {
            // Check for 'using "Iteratively"'
            if (node.Name.ToString() == ItlyVerifier.NameItlyNamespace)
            {
                var lineSpan = node.SyntaxTree.GetLineSpan(node.Span);
                this.References.Add(new ItlyReference(
                    this.FilePath,
                    "using " + node.Name.ToString(),
                    lineSpan.StartLinePosition.Line,
                    lineSpan.StartLinePosition.Character
                ));
            }
        }

        public override void VisitExpressionStatement(ExpressionStatementSyntax node)
        {
            // Console.WriteLine("[VisitExpressionStatement]");
            // Console.WriteLine(node);
            var invocationExpression = node.Expression as InvocationExpressionSyntax;
            if (invocationExpression != null)
            {
                var memberAccessExperession = invocationExpression.Expression as MemberAccessExpressionSyntax;
                if (memberAccessExperession != null)
                {
                    var names = GetIdentifierValues(memberAccessExperession);
                    // e.g. ["Itly", "Identify"], ["Console", "Log"], etc

                    // Check for Itly.X()
                    if (names.Length > 1 && this.AmpliInstanceNames.IndexOf(names[0]) >= 0)
                    {
                        var functionName = names[1];
                        // e.g. "Idenitify", "EventNoProperties", "Track", etc

                        // Handle generic Itly.Track()
                        if (functionName == ItlyVerifier.NameItlyTrackMethod) {
                            var argNames = GetIdentifierValues(invocationExpression.ArgumentList);
                            // e.g. ["userId", "EventNoProperties"]

                            if (argNames != null && argNames.Length > 1) {
                                functionName = argNames[1];
                            }
                        }

                        var lineSpan = node.SyntaxTree.GetLineSpan(node.Span);
                        this.References.Add(new ItlyReference(
                            this.FilePath,
                            functionName,
                            lineSpan.StartLinePosition.Line,
                            lineSpan.StartLinePosition.Character
                        ));
                    }
                }
            }
        }

        private string[] GetIdentifierValues(SyntaxNode node)
        {
            var names = from idName in node.DescendantNodes()
                            .OfType<IdentifierNameSyntax>()
            select idName.Identifier.ValueText;
            return names.ToArray();
        }
    }

    internal interface IToDict
    {
        Dictionary<string, object> ToDict();
    }

    internal class JsonHelper
    {
        public static String ToJson(object obj)
        {
            if (obj == null)
                return "null";

            var aDictionary = obj as Dictionary<string, object>;
            var aList = obj as List<object>;
            var aCollection = obj as ICollection<object>;

            List<string> items = new List<string>();
            if (aDictionary != null)
            {
                foreach(var kvp in aDictionary)
                {
                    items.Add($"\"{kvp.Key}\": {ToJson(kvp.Value)}");
                }
                return $"{{{String.Join(", ", items)}}}";
            }
            if (aList != null)
            {
                foreach(var item in aList)
                    items.Add(ToJson(item));
                return $"[{String.Join(", ", items)}]";
            }
            if (aCollection != null)
            {
                foreach(var item in aCollection)
                    items.Add(ToJson(item));
                return $"[{String.Join(", ", items)}]";
            }
            if (obj is string) {
                return $"\"{obj}\"";
            }
            return obj.ToString();
        }
    }
}