Untitled

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;

namespace Day7
{
    public class Folder
    {
        public string Name { get; set; }
        public List<Folder> Folders { get; set; }
        public List<Item> Items { get; set; }
    }
    public class Item
    {
        public int Size { get; set; }
    }

    internal class Program
    {
        public static string[] Input => File.ReadAllLines(@"input.txt").ToArray();
        public static List<Folder> allFolders => new List<Folder>();

        static void Main(string[] args)
        {
            var allFolders = new List<Folder>();

            int lastItem = Input.Skip(2).ToList().FindIndex(x => x.StartsWith("$ cd")) + 2;
            var children = Input[2..lastItem];

            var Myfolder = new Folder()
            {
                Name = "root",
                Folders = children.Any(x => x.StartsWith("dir ")) ? GetFoldersRecursive(children, new List<Folder>()) : new List<Folder>(),
                Items = GetFiles(children)
            };
            allFolders.Add(Myfolder);

            var value = CheckFoldersRecursive(allFolders, new List<int>(), 0);

            var summerized = value.Sum();

            Console.WriteLine(value);
            Console.ReadLine();
        }
        public static List<int> CheckFoldersRecursive(List<Folder> folders, List<int> values, int combo = 0)
        {
            foreach (var folder in folders)
            {
                if (combo > 0)
                {
                    if (folder.Items.Select(x => x.Size).Sum() + combo < 100000 && folder.Folders.Any())
                    {
                        var combinedLevel = folder.Items.Select(x => x.Size).Sum();
                        CheckFoldersRecursive(folder.Folders, values, combinedLevel);
                    }
                    else if (folder.Items.Select(x => x.Size).Sum()*2 + combo < 100000)
                    {
                        values.Add(folder.Items.Select(x => x.Size).Sum()*2 + combo);
                        break;
                    }
                }
                else
                {
                    if (folder.Items.Any())
                    {
                        combo = 0;
                        if (folder.Items.Select(x => x.Size).Sum() < 100000 && folder.Folders.Any())
                        {
                            var combinedLevel = folder.Items.Select(x => x.Size).Sum();
                            CheckFoldersRecursive(folder.Folders, values, combinedLevel);
                        }
                        else if (folder.Items.Select(x => x.Size).Sum() < 100000)
                        {
                            values.Add(folder.Items.Select(x => x.Size).Sum());
                        }
                    }
                    if (folder.Folders.Any())
                    {
                        CheckFoldersRecursive(folder.Folders, values);
                    }
                }
            }
            return values;
        }

        public static List<Folder> GetFoldersRecursive(string[] children, List<Folder> folders)
        {
            folders = new List<Folder>();

            foreach (var child in children)
            {
                if (child.StartsWith("dir"))
                {
                    int firstItem = Input.ToList().FindIndex(x => x == $"$ cd {child.Split(' ')[1]}") + 2;

                    var childrenToTake = Input.Skip(firstItem).ToList().FindIndex(x => x.StartsWith("$ cd")) != -1 ? 
                        Input.Skip(firstItem).ToList().FindIndex(x => x.StartsWith("$ cd")) : Input.Length;
                    var allChildren = Input.Skip(firstItem).Take(childrenToTake).ToArray();

                    if (allChildren.Any(x => x.StartsWith("dir ")))
                    {
                        var folderToAdd = new Folder() {
                            Name = child.Split(' ')[1],
                            Items = GetFiles(allChildren),
                            Folders = GetFoldersRecursive(allChildren, folders)
                        };
                        folders.Add(folderToAdd);
                    }
                    else
                    {
                        var folderToAdd = new Folder()
                        {
                            Name = child.Split(' ')[1],
                            Items = GetFiles(allChildren),
                            Folders = new List<Folder>()
                        };
                        folders.Add(folderToAdd);
                    }
                }
            }
            return folders;
        }
        public static List<Item> GetFiles(string[] children)
        {
            var files = new List<Item>();
            foreach (var child in children)
            {
                var i = 0;
                if (int.TryParse(child.Split(' ')[0], out i))
                {
                    files.Add(new Item() { Size = int.Parse(child.Split(' ')[0]) });
                }
            }
            return files;
        }
    }
}








//private void GetChildrenRecursive(ContentReference parent, List<ContentPage> list)
//{
//    var contentLoader = ServiceLocator.Current.GetInstance<IContentLoader>();
//    foreach (var child in contentLoader.GetChildren<ContentPage>(parent))
//    {
//        list.Add(child);
//        GetChildrenRecursive(child.ContentLink, list);
//    }
//}