using System;
using ModuleManager.Extensions;
using ModuleManager.Logging;
using ModuleManager.Patches;
using ModuleManager.Progress;
using ModuleManager.Tags;

namespace ModuleManager
{
    public class PatchExtractor
    {
        private readonly IPatchProgress progress;
        private readonly IBasicLogger logger;
        private readonly INeedsChecker needsChecker;
        private readonly ITagListParser tagListParser;
        private readonly IProtoPatchBuilder protoPatchBuilder;
        private readonly IPatchCompiler patchCompiler;

        public PatchExtractor(
            IPatchProgress progress,
            IBasicLogger logger,
            INeedsChecker needsChecker,
            ITagListParser tagListParser,
            IProtoPatchBuilder protoPatchBuilder,
            IPatchCompiler patchCompiler
        )
        {
            this.progress = progress ?? throw new ArgumentNullException(nameof(progress));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.needsChecker = needsChecker ?? throw new ArgumentNullException(nameof(needsChecker));
            this.tagListParser = tagListParser ?? throw new ArgumentNullException(nameof(tagListParser));
            this.protoPatchBuilder = protoPatchBuilder ?? throw new ArgumentNullException(nameof(protoPatchBuilder));
            this.patchCompiler = patchCompiler ?? throw new ArgumentNullException(nameof(patchCompiler));
        }

        public IPatch ExtractPatch(UrlDir.UrlConfig urlConfig)
        {
            if (urlConfig == null) throw new ArgumentNullException(nameof(urlConfig));

            try
            {
                int index = urlConfig.parent.configs.IndexOf(urlConfig);
                urlConfig.parent.configs.RemoveAt(index);

                if (!urlConfig.type.IsBracketBalanced())
                {
                    progress.Error(urlConfig, "Error - node name does not have balanced brackets (or a space - if so replace with ?):\n" + urlConfig.SafeUrl());
                    return null;
                }

                Command command = CommandParser.Parse(urlConfig.type, out string name);
                
                if (command == Command.Replace)
                {
                    progress.Error(urlConfig, $"Error - replace command (%) is not valid on a root node: {urlConfig.SafeUrl()}");
                    return null;
                }
                else if (command == Command.Create)
                {
                    progress.Error(urlConfig, $"Error - create command (&) is not valid on a root node: {urlConfig.SafeUrl()}");
                    return null;
                }
                else if (command == Command.Rename)
                {
                    progress.Error(urlConfig, $"Error - rename command (|) is not valid on a root node: {urlConfig.SafeUrl()}");
                    return null;
                }
                else if (command == Command.Paste)
                {
                    progress.Error(urlConfig, $"Error - paste command (#) is not valid on a root node: {urlConfig.SafeUrl()}");
                    return null;
                }
                else if (command == Command.Special)
                {
                    progress.Error(urlConfig, $"Error - special command (*) is not valid on a root node: {urlConfig.SafeUrl()}");
                    return null;
                }

                ITagList tagList;
                try
                {
                    tagList = tagListParser.Parse(name, urlConfig);
                }
                catch (FormatException ex)
                {
                    progress.Error(urlConfig, $"Cannot parse node name as tag list: {ex.Message}\non: {urlConfig.SafeUrl()}");
                    return null;
                }

                ProtoPatch protoPatch = protoPatchBuilder.Build(urlConfig, command, tagList);

                if (protoPatch == null)
                {
                    return null;
                }

                if (protoPatch.needs != null && !needsChecker.CheckNeedsExpression(protoPatch.needs))
                {
                    progress.NeedsUnsatisfiedRoot(urlConfig);
                    return null;
                }
                else if (!protoPatch.passSpecifier.CheckNeeds(needsChecker, progress))
                {
                    return null;
                }
                
                if (command == Command.Insert)
                {
                    ConfigNode newNode = urlConfig.config.DeepCopy();
                    newNode.name = protoPatch.nodeType;
                    newNode.id = urlConfig.config.id;
                    needsChecker.CheckNeedsRecursive(newNode, urlConfig);
                    urlConfig.parent.configs.Insert(index, new UrlDir.UrlConfig(urlConfig.parent, newNode));
                    return null;
                }
                else
                {
                    needsChecker.CheckNeedsRecursive(urlConfig.config, urlConfig);
                    return patchCompiler.CompilePatch(protoPatch);
                }
            }
            catch(Exception e)
            {
                progress.Exception(urlConfig, $"Exception while attempting to create patch from config: {urlConfig.SafeUrl()}", e);
                return null;
            }
        }
    }
}