//Copyright 2012-2023 Keysight Technologies
//
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;

namespace OpenTap.Plugins.PluginDevelopment
{
    // This example shows how to implement IArtifactListener
    // to make a result listener which can zip artifacts from the test plan run.
    [Display("Artifacts Zip")]
    public class ZipArtifactsResultListener : ResultListener, IArtifactListener
    {
        // Let the user select where to save the file.
        [FilePath]
        public MacroString ZipFile { get; set; } = new MacroString
        {
            Text = "<Date>.zip"
        };

        public ZipArtifactsResultListener()
        {
            Name = "Zip";
        }

        public override void OnTestPlanRunStart(TestPlanRun planRun)
        {
            // when the test plan starts, create the archive and close the stream.
            // after that the file will exist.
            // We will be opening and closing the file to insert items as needed.

            base.OnTestPlanRunStart(planRun);
            var fileName = GetTmpFileName(planRun);
            var fstr = File.OpenWrite(fileName);
            new ZipArchive(fstr, ZipArchiveMode.Create, false).Dispose();
        }

        public override void OnTestPlanRunCompleted(TestPlanRun planRun, Stream logStream)
        {
            // When the test plan has completed, we can calculate the final name of it
            // and save it in the final location
            // and in addition publish it as an artifact.

            base.OnTestPlanRunCompleted(planRun, logStream);

            var fileName = GetTmpFileName(planRun);

            var finalName = ZipFile.Expand(planRun);
            try
            {
                // ensure that the folder exists before moving the file.
                var selectedFolder = Path.GetDirectoryName(Path.GetFullPath(finalName));
                if (string.IsNullOrEmpty(selectedFolder) == false)
                    Directory.CreateDirectory(selectedFolder);

                File.Move(fileName, finalName);
            }
            catch (IOException e)
            {
                if (e.Message.Contains("already exists"))
                {
                    // try finding another name for the file.
                    var ext = Path.GetExtension(finalName);
                    if (ext == null)
                    {
                        for (int i = 2; i < 20; i++)
                        {
                            var name2 = $"{finalName}.{i}";
                            if (!File.Exists(name2))
                            {
                                File.Move(fileName, name2);
                                break;
                            }
                        }
                    }
                    else
                    {
                        for (int i = 2; i < 20; i++)
                        {
                            var name2 = Path.ChangeExtension(finalName, $"{i}{ext}");
                            if (!File.Exists(name2))
                            {
                                File.Move(fileName, name2);
                                finalName = name2;
                                break;
                            }
                        }
                    }
                }
                else
                {
                    throw;
                }
            }
            this.Log.Debug("Wrote file: {0}", Path.GetFullPath(finalName));

            // finally publish the artifact.
            // This must be done asynchronously as we are currently inside a result processing thread.
            planRun.PublishArtifactAsync(File.OpenRead(finalName), Path.GetFileName(finalName));
        }

        // this map is used to keep track of the parent-child association between step runs and plan runs.
        readonly Dictionary<Guid, Guid> parentMap = new Dictionary<Guid, Guid>();

        public override void OnTestStepRunStart(TestStepRun stepRun)
        {
            base.OnTestStepRunStart(stepRun);
            parentMap.Add(stepRun.Id, stepRun.Parent);
        }

        public override void OnTestStepRunCompleted(TestStepRun stepRun)
        {
            base.OnTestStepRunCompleted(stepRun);
            parentMap.Remove(stepRun.Id);
        }

        Guid GetPlanRunId(Guid runId)
        {
            // get the plan run id of any step run, based on the id.
            // this assumes that the run id comes from the plan
            // and that the test plan run id is the topmost (has no parent).
            while (parentMap.TryGetValue(runId, out var runId2))
            {
                runId = runId2;
            }
            return runId;
        }

        string GetTmpFileName(TestRun run)
        {
            var id = GetPlanRunId(run.Id);
            var name = $"tmp.artifacts.{id}.zip";
            return name;
        }

        // this is the interface required by IArtifactListener
        // assume the artifactStream is a stream of data and artifactName is the name of the artifact
        // including possible extensions like 'png' or 'csv'.
        public void OnArtifactPublished(TestRun run, Stream artifactStream, string artifactName)
        {
            try
            {
                var fileName = GetTmpFileName(run);
                if (!File.Exists(fileName))
                    return; // The means file has been finalized (or something went wrong). After this we don't insert new data.

                // insert the object data into the zip file.
                var rawStream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete);
                using (var archive = new ZipArchive(rawStream, ZipArchiveMode.Update, false))
                {

                    var entry = archive.CreateEntry(artifactName);
                    using (var s2 = entry.Open())
                    {
                        artifactStream.CopyTo(s2);
                    }
                }
            }
            finally
            {

                artifactStream.Close();
            }
        }
    }
}