BeWoPlaner/Service/ServiceUtils/Update/DownloadPlanerResponseBuilder.cs

using BeWo.Service.ServiceUtils.Paths;
using BS.SharedLauncher.DataContract;
using BS.SharedLauncher.Exceptions;
using BS.SharedLauncher.Extensions;
using BS.SharedLauncher.Logic;
using BS.SharedLauncher.Update;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BeWo.Service.ServiceUtils.Update
{
    public class DownloadPlanerResponseBuilder
    {
        private PlanerPackageInfo currentUpdatePackageInfo;
        private PlanerPackageInfo latestUpdatePackageInfo;
        private Dictionary<string, List<string>> downloadFilesToKeep;

        public DownloadPlanerResponseBuilder(DownloadPlanerRequestDC req)
        {
            currentUpdatePackageInfo = null;
            latestUpdatePackageInfo = null;
            downloadFilesToKeep = null;
        }

        public PlanerPackageInfo CurrentUpdatePackageInfo => currentUpdatePackageInfo;
        public PlanerPackageInfo FullUpdatePackageInfo => latestUpdatePackageInfo;

        public void Calculate(string tenant)
        {
            PlanerPackageInfo root = new PlanerPackageInfo();
            UpdateConfigReader reader = new UpdateConfigReader(ServerFilePaths.GetVersionConfigFilePath(), tenant);

            root.DefaultVersion = reader.GetDefaultVersion();
            root.TenantVersion = reader.GetSpecificVersion();

            string version = root.Version;

            // Setze Basis 
            root.InitFiles(getVersionDefaultFiles(version));

            // Überschreibe mit Version-Tenant Daten
            root.OverrideFiles(getVersionTenantFiles(version, tenant));

            // Überschreibe mit Special-Tenant Daten
            root.OverrideFiles(getSpecialTenantFiles(tenant));

            // Lade Hash Werte
            root.LoadHash();

            latestUpdatePackageInfo = root;
            currentUpdatePackageInfo = root.Copy();
        }
        public void Substract(PlanerPackageInfo applyPackage)
        {
            currentUpdatePackageInfo.SubstractFiles(applyPackage.Files);
        }
        public void AnalyseDownload(Dictionary<string, PlanerPackageInfo> zip2info)
        {
            downloadFilesToKeep = new Dictionary<string, List<string>>();

            foreach (var z2i in zip2info)
            {
                bool found = false;

                for (int i = currentUpdatePackageInfo.Files.Count - 1; i >= 0; i--)
                //foreach (var file in currentUpdatePackageInfo.Files)
                {
                    var file = currentUpdatePackageInfo.Files[i];

                    if (z2i.Value.ContainsPlanerFile(file.RelativePath, file.Checksum))
                    {
                        if (!found)
                        {
                            found = true;
                            downloadFilesToKeep.Add(z2i.Key, new List<string>());
                        }

                        downloadFilesToKeep[z2i.Key].Add(file.RelativePath);

                        currentUpdatePackageInfo.RemoveFileAt(i);
                    }
                }
            }
        }
        public void Compress()
        {
            if (downloadFilesToKeep != null && !downloadFilesToKeep.Any())
                downloadFilesToKeep = null;

            if (currentUpdatePackageInfo != null && !currentUpdatePackageInfo.AnyFile())
                currentUpdatePackageInfo = null;
        }
        
        public DownloadPlanerResponseDC CreateResponse(DownloadPlanerRequestDC request)
        {
            var res = new DownloadPlanerResponseDC();

            Compress();
            
            res.LatestApplicationInfo = latestUpdatePackageInfo.ToPlanerPackageInfoDC();
            
            if (downloadFilesToKeep is object)
            {
                res.DownloadFilesToKeep = downloadFilesToKeep;
            }

            if (currentUpdatePackageInfo is object)
            {
                res.NewZipData = ZipArchiveBuilder.CreateZipArray(currentUpdatePackageInfo.Files,
                                                (file) => file.AbsolutePath, (file) => file.RelativePath);
                res.NewZipInfo = currentUpdatePackageInfo.ToPlanerPackageInfoDC();
                //res.NewZipStream = ZipArchiveBuilder.CreateZipStream(currentUpdatePackageInfo.Files,
                //                                (file) => file.AbsolutePath, (file) => file.RelativePath);
                //res.NewZipStreamLength = res.NewZipStream.Length;
            }

            res.HasToRemoveFiles = request.ApplyPackage?.Files?.Any(x => !res.LatestApplicationInfo.Files.Any(y => x.EqualsFile(y))) ?? false;

            

            return res;
        }

        private List<PlanerFileInfo> getVersionDefaultFiles(string version) => getPlanerFiles(ServerFilePaths.GetVersionDefaultFolderPath(version), false);
        private List<PlanerFileInfo> getVersionTenantFiles(string version, string tenant) => getPlanerFiles(ServerFilePaths.GetVersionTenantFolderPath(version, tenant), true);
        private List<PlanerFileInfo> getSpecialTenantFiles(string tenant) => getPlanerFiles(ServerFilePaths.GetOverrideTenantFolderPath(tenant), true);

        private List<PlanerFileInfo> getPlanerFiles(string path, bool ignore)
        {
            if (!Directory.Exists(path)) {
                if (ignore)
                    return new List<PlanerFileInfo>();
                else
                    throw new ServerConfigException($"{path} konnte nicht gefunden werden");
            }
            var res = FileController.GetPlanerFiles(path);

            //res.ForEach(x => x.Source = source);
            return res;
        }
    }
}