using System;

using System.Collections.Generic;

using System.Reflection;

using System.IO;

using System.IO.Compression;

using VPO = VirtualPathObject;

​

public class Program

{

    public static void Main()

    {

        string p = "test.zip";

        new System.Net.WebClient().DownloadFile(@"https://www.dropbox.com/s/spwfx62e7d26mr3/test.zip?dl=1", p);

        VPO v = new VPO(p, true);

        Console.WriteLine(v.ToString());

        v.Zip("test2.zip");

        Console.WriteLine("Success");

        Console.WriteLine(new VPO("test2.zip", true).ToString());

    }

}

​

public class VirtualPathObject

{

    public VirtualPathObject()

    {

    }

​

    public VirtualPathObject(string path, bool isZip = false)

    {

        if (isZip)

        {

            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

            ZipArchive za = ZipFile.Open(path, ZipArchiveMode.Read, System.Text.Encoding.GetEncoding(850));

            foreach (ZipArchiveEntry e in za.Entries)

            {

                Console.WriteLine(e);

                if (e.Name == string.Empty)

                    _ = GetChildFromPath(e.FullName);

                else /*if (e.Name != string.Empty)*/

                    SetChildFromPath(e.FullName, new VirtualPathObject<byte[]>(ReadFully(e.Open())));

            }

        }

    }

​

    public void Zip(string zipPath)

    {

        using FileStream fs = new FileStream(zipPath, FileMode.Create);

        using ZipArchive za = new ZipArchive(fs, ZipArchiveMode.Update);

        CreateEntries(za, null);

    }

​

    private void CreateEntries(ZipArchive za, string path = null)

    {

        if (path != null)

            path += "/";

        if (Children != null)

        {

            foreach (var c in Children)

            {

                if (c.Value.GetType().IsGenericType)

                    za.CreateEntry(path + c.Key);

                else

                    c.Value.CreateEntries(za, path + c.Key); 

            }

        }

    }

​

    private static byte[] ReadFully(Stream input)

    {

        byte[] buffer = new byte[16 * 1024];

        using (MemoryStream ms = new MemoryStream())

        {

            int read;

            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)

                ms.Write(buffer, 0, read);

            return ms.ToArray();

        }

    }

​

    public VirtualPathObject MakeDir(string name)

    {

        if (Children == null)

            Children = new ICDict<VirtualPathObject>();

        VirtualPathObject vpo = new VirtualPathObject();

        Children[name] = vpo;

        return vpo;

    }

​

    public VirtualPathObject this[params string[] path]

    {

        get => GetChild(path);

        set => SetChild(path, value);

    }

​

    public VirtualPathObject GetChild(string name)

    {

        if (Children != null && Children.ContainsKey(name))

            return Children[name];

        else

            return MakeDir(name);

    }

​

    public void SetChild(string name, VirtualPathObject value)

    {

        if (Children == null)

            Children = new ICDict<VirtualPathObject>();

        Children[name] = value;

    }

​

    private readonly char[] cDefSep = {'/', '\\'};

    public VirtualPathObject GetChildFromPath(string path) => GetChildFromPath(path, cDefSep);

    public VirtualPathObject GetChildFromPath(string path, char[] sep) => GetChild(path.Split(sep, StringSplitOptions.RemoveEmptyEntries));

    public VirtualPathObject GetChild(string[] path)

    {

        if (path.Length == 0)

            throw new ArgumentException();

        else if (path.Length == 1)

            return GetChild(path[0]);

        else

        {

            string[] newPath = new string[path.Length - 1];

            for (int i = 0; i < newPath.Length; i++)

                newPath[i] = path[i + 1];

            return GetChild(path[0])[newPath];

        }

    }

​

    public void SetChildFromPath(string path, VirtualPathObject value) => SetChildFromPath(path, value, cDefSep);

    public void SetChildFromPath(string path, VirtualPathObject value, char[] sep) => SetChild(path.Split(sep, StringSplitOptions.RemoveEmptyEntries), value);

    public void SetChild(string[] path, VirtualPathObject value)

    {

        if (path.Length == 0)

            throw new ArgumentException();

        else if (path.Length == 1)

            SetChild(path[0], value);

        else

        {

            string[] newPath = new string[path.Length - 1];

            for (int i = 0; i < newPath.Length; i++)

                newPath[i] = path[i + 1];

            GetChild(path[0]).SetChild(newPath, value);

        }

    }

​

    public override string ToString() => ToString(base.ToString());

    public string ToString(string name)

    {

        string s = name;

        if (Children != null)

        {

            s += "\n{";

            foreach (var c in Children)

                s += "\n" + ((c.Key + ": ").PadRight(25) + c.Value.ToString() + "").Shift(4);

            s += "\n}";

        }

​

        try

        {

            object o;

            if ((o = Content) != null)

                s = o.ToString();

        }

        catch

        {

        }

​

        return s;

    }

​

    public object Content

    {

        get

        {

            if (GetType().IsGenericType)

                foreach (PropertyInfo pi in GetType().GetProperties())

                    if (pi.Name == nameof(Content) && pi.DeclaringType.IsGenericType)

                        return pi.GetValue(this);

            throw new InvalidOperationException("Content can only be received from objects of the inherited type VirtualPathObject<T>.");

        }

    }

​

    public ICDict<VirtualPathObject> Children

    {

        get;

        set;

    }

​

    = null;

}

​

public class VirtualPathObject<T> : VirtualPathObject

{

    public VirtualPathObject()

    {

    }

​

    public VirtualPathObject(T content)

    {

        Content = content;

    }

​

    public new T Content

    {

        get;

        set;

    }

​

    = default(T);

}

​

public interface ISavable

{

}

​

public class ICDict<T> : Dictionary<string, T>

{

    public ICDict(): base(StringComparer.OrdinalIgnoreCase)

    {

    }

}

​

public static class ext

{

    public static string Shift(this string s, int n)

    {

        string r = string.Empty;

        string[] l = s.Split('\n');

        for (int i = 0; i < l.Length; i++)

            r += (i == 0 ? string.Empty : "\n") + string.Empty.PadRight(n) + l[i];

        return r;

    }

​

    public static string AsString(this byte[] b) => System.Text.Encoding.Default.GetString(b ?? new byte[0]);

}