using qdr.app.tools.qfu.Commands.Aspects;
using Quadarax.Foundation.Core.QConsole;
using Quadarax.Foundation.Core.QConsole.Argument;
using Quadarax.Foundation.Core.QConsole.Attributes;
using Quadarax.Foundation.Core.Value;

namespace qdr.app.tools.qfu.Commands
{
    [CommandDefinition]

    internal class CloneCmd : BaseCmd
    {
        #region *** Constants ***
        private const string CMD_NAME = "clone";
        private const string CMD_DESCR = "Clone source file to files specified.";
        #endregion

        #region *** Properties ***
        public override string Name => CMD_NAME;
        public override string Description => CMD_DESCR;

        protected string[] TargetFiles { get; private set; } = Array.Empty<string>();
        protected bool IsEnsurePath { get; private set; } = false;
        protected bool IsForce { get; private set; } = false;
        #endregion

        #region *** Constructors ***
        public CloneCmd(Engine engine) : base(engine)
        {
        }
        #endregion

        #region *** Overrides ***
        #region **** EXECUTE ****
        protected override Result OnExecute()
        {
            WriteCaption($"Will be clonig file '{Source}' to {TargetFiles.Length} files {(IsForce ? "(with force)": string.Empty)}... ");
            var cnt = 0;
            var succ = 0;
            var bSucc = true;
            foreach (var file in TargetFiles)
            {
                cnt++;
                if (FileSystem.File.Exists(file) && !IsEnsurePath)
                {
                    if (!IsForce)
                    {
                        WriteWarning($"[{cnt}] File '{file}' already exists. Skipping clone operation.");
                        continue;
                    }
                }
                try
                {
                    FileSystem.File.Copy(Source, file, true);
                    if (FileSystem.File.Exists(file))
                        succ++;
                    else
                        WriteWarning($"[{cnt}] File '{file}' does not exist after copy operation.");
                    WriteInfo($"[{cnt}] Cloned '{Source}' to '{file}' successfully.");
                }
                catch (Exception ex)
                {
                    WriteError($"[{cnt}] Failed to clone '{Source}' to '{file}': {ex.Message}");
                    bSucc = false;
                }
            }

            WriteCaption($"Succesfully cloned: {succ} of {cnt} files.");
            bSucc = succ == cnt;
            return bSucc ? new Result() : new Result(new Exception($"Failed to clone {TargetFiles.Length - succ} files from '{Source}'."));
        }
        #endregion
        #region **** Arguments ****
        protected override void OnValidateArguments()
        {
            base.OnValidateArguments();
            CheckSourceFileExists();
            TargetFiles = ListAspect.GetFiles(this, FileSystem, FilesAspect.GetFiles(this, FileSystem, false));
            IsEnsurePath = GetArgumentValueOrDefault<bool>(FilesAspect.ARG_PATHENS_NAME, false);
            IsForce = GetArgumentValueOrDefault<bool>(ForceAspect.ARG_FORCE_NAME, false);
        }

        protected override IEnumerable<AbstractArgument> OnSetupArguments()
        {
            var list = base.OnSetupArguments().ToList();
            list.AddRange(ListAspect.SetupArguments());
            list.AddRange(FilesAspect.SetupArguments());
            list.AddRange(ForceAspect.SetupArguments());
            return list;
        }

        #endregion
        #endregion
    }
}