using System;
using System.IO;
using System.Linq;
using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;
using System.Text.RegularExpressions;

namespace OpenTap.Engine.UnitTests.TestTestSteps
{
    [Display("Write File", Description: "Writes a string to a file.", Group: "Tests")]
    public class WriteFileStep : TestStep
    {
        [Layout(LayoutMode.Normal, rowHeight: 5)]
        public string String { get; set; }
        public string File { get; set; }
        public override void Run() => System.IO.File.WriteAllText(File, String);
    }

    [Display("Create Directory", Description: "Creates a new directory.", Group: "Tests")]
    public class CreateDirectoryStep : TestStep
    {
        public string Directory { get; set; }
        public override void Run()
        {
            System.IO.Directory.CreateDirectory(Directory);
        }
    }

    [Display("Replace In File", Description: "Replaces some text in a file.", Group: "Tests")]
    public class ReplaceInFileStep : TestStep
    {
        [FilePath]
        [Display("File", Order: 0)]
        public string File { get; set;}
        [Layout(LayoutMode.Normal, rowHeight: 5)]
        [Display("Search For", Order: 1)]
        public string Search { get; set; }
        [Layout(LayoutMode.Normal, rowHeight: 5)]
        [Display("Replace With", Order: 2)]
        public string Replace { get; set; }

        public override void Run()
        {
            var content = System.IO.File.ReadAllText(File);
            content = content.Replace(Search, Replace);
            System.IO.File.WriteAllText(File, content);
        }
    }

    [Display("Expect", Description: "Expects  verdict in the child step.", Group: "Tests")]
    [AllowAnyChild]
    public class ExpectStep : TestStep
    {
        public Verdict ExpectedVerdict { get; set; }
        public override void Run()
        {
            RunChildSteps();
            if (Verdict == ExpectedVerdict)
                Verdict = Verdict.Pass;
            else
            {
                Verdict = Verdict.Fail;
            }
        }
    }

    public enum VersionType
    {
        FileVersion,
        SemanticVersion
    }

    [Display("Read Assembly Version", Group: "Tests")]
    public class ReadAssemblyVersionStep : TestStep
    {
        [FilePath]
        public string File { get; set; }
        
        public string MatchVersion { get; set; }
        public VersionType VersionType { get; set; }

        void CheckFileVersion()
        {
            var semver = GetVersion(File);
            if (semver == null)
            {
                Log.Error("Unable to read version info.");
            }

            if (string.IsNullOrWhiteSpace(MatchVersion) == false)
            {
                if (Equals(semver.ToString(), MatchVersion))
                {
                    UpgradeVerdict(Verdict.Pass);
                }
                else
                {
                    UpgradeVerdict(Verdict.Fail);
                }
            }
            Log.Info("Read Version {0}", semver.ToString());
            
        }

        void CheckSemanticVersion()
        {
            if (!SemanticVersion.TryParse(MatchVersion, out var semver))
            {
                Log.Error($"{MatchVersion} is not a semantic version.");
                UpgradeVerdict(Verdict.Error);
                return;
            }
            
            var s = PluginManager.GetSearcher();
            s.AddAssembly(File, null);

            string normalize(string s)
            {
                return Path.GetFullPath(s).TrimEnd('/', '\\');
            }

            var nf = normalize(File);
            var asm = s.Assemblies.FirstOrDefault(a => normalize(a.Location).Equals(nf, StringComparison.OrdinalIgnoreCase));

            if (asm == null)
            {
                Log.Error("Assembly not loaded.");
                UpgradeVerdict(Verdict.Error);
                return;
            }

            var asmVer = asm.SemanticVersion;

            if (Equals(asmVer.ToString(), semver.ToString()))
            {
                UpgradeVerdict(Verdict.Pass);
            }
            else
            {
                UpgradeVerdict(Verdict.Fail);
            }
            Log.Info("Read Version {0}", asmVer.ToString());
        }

        public override void Run()
        {
            if (false == System.IO.File.Exists(File))
                throw new FileNotFoundException("File does not exist", File);

            switch (VersionType)
            {
                case VersionType.FileVersion:
                    CheckFileVersion();
                    break;
                case VersionType.SemanticVersion:
                    CheckSemanticVersion();
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        public static SemanticVersion GetVersion(string path)
        {
            var searcher = new PluginSearcher();
            searcher.Search(new[] {path});
            Log.Debug("Searching {0}", path);
            var asm = searcher.Assemblies.First();
            using (FileStream file = new FileStream(asm.Location, FileMode.Open, FileAccess.Read))
            using (PEReader header = new PEReader(file, PEStreamOptions.LeaveOpen))
            {
                var CurrentReader = header.GetMetadataReader();
                Log.Debug("Opened file");
                foreach (CustomAttributeHandle attrHandle in CurrentReader.GetAssemblyDefinition().GetCustomAttributes())
                {
                    
                    CustomAttribute attr = CurrentReader.GetCustomAttribute(attrHandle);
                    Log.Info("attribute: {0}",attr.Constructor.Kind);
                    if (attr.Constructor.Kind == HandleKind.MemberReference)
                    {
                        var ctor = CurrentReader.GetMemberReference((MemberReferenceHandle) attr.Constructor);
                        string attributeFullName = "";
                        if (ctor.Parent.Kind == HandleKind.TypeDefinition)
                        {
                            var def = CurrentReader.GetTypeDefinition((TypeDefinitionHandle)ctor.Parent);
                            attributeFullName = string.Format("{0}.{1}", CurrentReader.GetString(def.Namespace), CurrentReader.GetString(def.Name));
                        }
                        if (ctor.Parent.Kind == HandleKind.TypeReference)
                        {
                            var r = CurrentReader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
                            attributeFullName = string.Format("{0}.{1}", CurrentReader.GetString(r.Namespace), CurrentReader.GetString(r.Name));
                        }
                        Log.Info("Found attribute: {0}", attributeFullName);

                        if (attributeFullName == typeof(System.Reflection.AssemblyInformationalVersionAttribute).FullName)
                        {
                            var valueString = attr.DecodeValue(new CustomAttributeTypeProvider());
                            if (SemanticVersion.TryParse(valueString.FixedArguments[0].Value.ToString(), out SemanticVersion infoVer))
                                return infoVer;
                        }
                    }
                }
            }
            Log.Warning("No Version found");
            return null;
        }

        struct CustomAttributeTypeProvider : ICustomAttributeTypeProvider<TypeData>
        {
            public TypeData GetPrimitiveType(PrimitiveTypeCode typeCode){return null;}
            public TypeData GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind){return null;}
            public TypeData GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind){return null;}
            public TypeData GetSZArrayType(TypeData elementType){return null;}
            public TypeData GetSystemType(){return null;}
            public bool IsSystemType(TypeData type){throw new System.NotImplementedException();}
            public TypeData GetTypeFromSerializedName(string name){return null;}
            public PrimitiveTypeCode GetUnderlyingEnumType(TypeData type){throw new System.NotImplementedException();}
        }
    }

    [Display("Remove Directory", "Removes a directory.", "Tests")]
    public class RemoveDirectory : TestStep
    {
        [DirectoryPath]
        public string Path { get; set; }
        public override void Run()
        {
            if (Directory.Exists(Path))
                Directory.Delete(Path, true);
        }
    }

    
    [AllowAnyChild]
    [Display("Run On OS", "Runs the child steps on a specific OS.", "Tests")]
    public class RunOnOs : TestStep
    {

        public string[] AvailableOperatingSystems => new []{ "MacOS", "Linux", "Windows"};

        [AvailableValues(nameof(AvailableOperatingSystems))]
        public string OperatingSystem { get; set; } = "Windows";
        
        public RunOnOs()
        {
            this.Name = "Run On {OperatingSystem}";
        }
        
        public override void Run()
        {
            if (OpenTap.OperatingSystem.Current.Name == OperatingSystem)
            {
                RunChildSteps();
            }
            else
            {
                Log.Info("Skipping Child Steps On {0}", OpenTap.OperatingSystem.Current);
            }
        }
    }

    [Display("Find File Step", "Finds a file in a dir. Pass when found, fail if not.", "Tests")]
    public class FindFileStep : TestStep
    {
        [DirectoryPath] public MacroString SearchDir { get; set; } = new MacroString {Text = "."};

        public string Regex { get; set; } = "\\.zip";

        public override void Run()
        {
            var dir = SearchDir.Expand(this.PlanRun);
            var regex = new Regex(Regex);
            foreach(var file in Directory.GetFiles(dir))
            {
                
                if (regex.IsMatch(file))
                {
                    Log.Debug("Matched file: {0}", file);
                    UpgradeVerdict(Verdict.Pass);
                    return;
                }
            }
            UpgradeVerdict(Verdict.Fail);
        }
    }
}