using System;

using System.Collections.Generic;

    public enum InteractableTypes

    {

        WoodDoor=0,

        MetalDoor,

        Window,

        Lock,

        NEW_ASS,

    }

public class Program //this can be the ObjectHandler

{

    static List<Interactable> allActors;

    static public List<DataStruct> modifiedDatas;

    static List<PlaceHolder> placeHolders;

    public static Dictionary<string, DataStruct> dataMap;

    static int loads = 1;

    static int saves = 1;

    public static void Main()

    {

        allActors = new List<Interactable>();

        modifiedDatas = new List<DataStruct>();

        dataMap = new Dictionary<string, DataStruct>();

        placeHolders = new List<PlaceHolder>();

        //placeholders in the scene

        placeHolders.Add(new PlaceHolder(new DataStruct("doorPH", InteractableTypes.WoodDoor)));

        placeHolders.Add(new PlaceHolder(new DataStruct("windowPH", InteractableTypes.Window)));

        //now we run our simulation

        LoadLevel();                                //load our stock level

        foreach(var actor in allActors)             //modify all transforms

            actor.FuckAround();     

        SaveLevel(true);                            //save again, detect the door and add a lock

        LoadLevel();                                //load again, including the lock as a child of window

        Console.Write("\n\n\n");

    }

    static void LoadLevel()

    {

        Console.WriteLine("\nBeginning Load #" + loads);

        //erase Interactables in scene (keep placeholders and data)

        allActors.Clear();

        //create objects in scene from placeholders 

        foreach(var ph in placeHolders)//assign objects to the placeholders

        {

            allActors.Add(Interactable.CreateInteractableFromData(ph.data));

            Console.WriteLine("from placeholder");

        }

        //now create other interactables, non-placeholder origin

        allActors.Add(new WoodDoor(new DataStruct("wooddoor01", InteractableTypes.WoodDoor)));

        Console.WriteLine("from non-placeholder");      

        PrintScene();

        Console.WriteLine($"Finished Load #{loads++}\n");

    }

    static void SaveLevel(bool detect)

    {

        Console.WriteLine("\nBeginning Save #" + saves);

        if(detect) Detection();

        foreach(var obj in allActors)

        {

            UpdateDataMap(obj.data);

        }

        PrintScene();

        Console.WriteLine("Finished Save #" + saves++);

    }

    static void Detection() //this just detects the first one in the modified list

    {

        if(modifiedDatas.Count==0) return;

        var obj = FindInteractableByID(modifiedDatas[0].ID);

        obj.SecurityUp();

        modifiedDatas.RemoveAt(0);

    }

    static Interactable FindInteractableByID(string dataID)

    {

        foreach(var actor in allActors)

        {

            if(actor.data.ID == dataID)

                return actor;

        }

        return null;

    }

​

    static public void UpdateDataMap(DataStruct data)

    {

        if(dataMap.ContainsKey(data.ID))

            dataMap[data.ID] = data;

        else

            dataMap.Add(data.ID, data);

    }

    /*static bool GetDataFromDataMap(string ID, out DataStruct data)

    {

        if(dataMap.ContainsKey(ID))

        {

            data = dataMap[ID];

            return true;

        }

        data = new DataStruct();

        return false;

    }*/

    static void PrintScene()

    {

        Console.WriteLine("Scene Snapshot");

        foreach(var actor in allActors)

        {

            //Console.Write("\t");

            actor.Print();

            }

    }   

}

​

//==============================INTERACTABLE=========================================

public abstract class Interactable 

{

    public DataStruct data;

    Interactable child; //maybe null, maybe child

    protected Interactable(DataStruct _data)

    {

        //before we assign the provided data struct, let's check for an updated version

        if(Program.dataMap.ContainsKey(_data.ID))

        {

            _data = Program.dataMap[_data.ID];

        }

        data = _data;

        Init();

    }

    public void Init()

    {

        if(data.childID != null) //data info says there will be a child object

        {

            AddChild(CreateInteractableFromData(Program.dataMap[data.childID]));

        }

    }

    void PostInit()

    {

    }

​

    public static Interactable CreateInteractableFromData(DataStruct data)

    {

        Interactable obj = null;

        switch(data.type)

        {           

            case InteractableTypes.WoodDoor:

                obj = new WoodDoor(data);

                break;

            case InteractableTypes.MetalDoor:

                obj = new MetalDoor(data);

                break;

            case InteractableTypes.Window:

                obj = new Window(data);

                break;

            case InteractableTypes.Lock:

                obj = new Lock(data);

                break;

        }

        return obj;

    }

​

​

    public void SecurityUp()

    {       

        data.transform = 0; //reset state/transform

        AddChild(new Lock(new DataStruct("lock_01", InteractableTypes.Lock))); //create object in scene and link it as child to this Data

        Console.WriteLine("on " + data.ID + " from security upgrade");

    }

    public void AddChild(Interactable ch)

    {

        child = ch;

        data.childID = child.data.ID;

        Program.UpdateDataMap(ch.data);

    }

    public void FuckAround()

    {

        data.transform += 1.207; //change the transform

        //if modified, add to list

        if(!Program.modifiedDatas.Contains(data))

            Program.modifiedDatas.Add(data);

    }

    public void Print()

    {

        string temp = string.Empty;

        if(child != null)

            temp = $"[child: {child.data.ID}]";

        Console.WriteLine($"[ID: {data.ID}] [transform: {data.transform}] {temp}");

        if(child != null)

            child.Print();   

    }

}

//==========================INTERACTABLE===SUBCLASSES=================================

public class WoodDoor : Interactable

{

    public WoodDoor(DataStruct _data) : base(_data)

    {

        Console.Write("creating WoodDoor ");

    }

}

public class MetalDoor : Interactable

{

    public MetalDoor(DataStruct _data) : base(_data)

    {

        Console.Write("creating MetalDoor ");

    }

}

public class Window : Interactable

{

    public Window(DataStruct _data) : base(_data)

    {

        Console.Write("creating Window ");

    }

}

public class Lock : Interactable

{

    public Lock(DataStruct _data) : base(_data)

    {

        Console.Write("creating Lock ");

    }

}

//==============================DATA=STRUCT==========================================

public struct DataStruct

{

    public DataStruct(string id, InteractableTypes _type)

    {

        ID = id;

        type = _type;

    }

    public InteractableTypes type;

    public string ID;

    public string childID;

    public double transform;

}

​

//=================================PLACEHOLDER=======================================

public class PlaceHolder

{   

    public DataStruct data;

    public PlaceHolder(DataStruct _data)

    {

        data = _data;       

    }

}

​

​