LevelObj.cs

using EditorCore;
using EditorCore.Interfaces;
using ExtensionMethods;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing.Design;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.Windows.Media.Media3D;
using static EditorCore.PropertyGridTypes;

namespace OdysseyExt
{
    public class LevelObj : ILevelObj
	{
		public static ILevelObj FromNode(dynamic bymlNode)
		{
			if (!(bymlNode is Dictionary<string, dynamic>)) throw new Exception("Not a dictionary");
			var node = (Dictionary<string, dynamic>)bymlNode;
			if (node.ContainsKey(N_Id) && ((string)node[N_Id]).StartsWith("rail"))
				return new Rail(node);
			else
				return new LevelObj(node);
		}

		[Browsable(false)]
		public bool ReadOnly { get; set; } = false; //if the model is static and doesn't appear in the list (mk8 courses)
		
        public const string N_Translate = "Translate";
        public const string N_Rotate = "Rotate";
        public const string N_Scale = "Scale";
        public const string N_Id = "Id";
        public const string N_Name = "UnitConfigName";
        public const string N_ModelName = "ModelName";
        public const string N_Links = "Links";
		public const string N_LinkDest = "IsLinkDest";
		public const string N_LayerConfigName = "LayerConfigName";
		public const string N_PlacementFileName = "PlacementFileName";
		public const string N_Comment = "comment";

		public const string N_LinkReferenceList = "SrcUnitLayerList";
		public const string N_ResourceCategory = "SrcUnitLayerList";

		public static readonly string[] CantRemoveNames = { N_Translate, N_Rotate, N_Scale, N_Id , N_Name , N_Links, N_LinkDest, N_LayerConfigName , N_PlacementFileName };
		public static readonly string[] ModelFieldNames = { N_Name, N_ModelName };

		public const string N_UnitConfig = "UnitConfig";
		public const string N_UnitConfigModel = "DisplayName";
		public const string N_UnitConfigPos = "DisplayTranslate";
		public const string N_UnitConfigRot = "DisplayRotate";
		public const string N_UnitConfigScale = "DisplayScale";
		public const string N_UnitConfigGenList = "GenerateCategory";
		public const string N_UnitConfigBaseClass = "ParameterConfigName";
		public const string N_UnitConfigGenTarget = "PlacementTargetFile";

		[System.ComponentModel.DisplayName("Properties")]
		[TypeConverter(typeof(DictionaryConverter))]
		[Description("This contains every property of this object")]
		public Dictionary<string, dynamic> Prop { get; set; } = new Dictionary<string, dynamic>();

		public LevelObj(Dictionary<string, dynamic> bymlNode)
        {
			Prop = bymlNode;
			if (Prop.ContainsKey(N_Links) && !(Prop[N_Links] is LinksNode)) Prop[N_Links] = new LinksNode(Prop[N_Links]);
        }
        
		public LevelObj(bool empty = false)
        {
            if (empty) return;
            Prop.Add(N_Translate, NodeVec3(0,0,0));
			Prop.Add(N_Rotate, NodeVec3(0,0,0));
			Prop.Add(N_Scale, NodeVec3(1, 1, 1));
			Prop.Add(N_Links, new LinksNode());
            this[N_Name] = "newObj";
            this[N_Id] = "obj0";
			this[N_LinkDest] = false;
			this[N_LayerConfigName] = "Common";
			this[N_PlacementFileName] = "Undefined";
			//this[N_Comment] = null;
			Prop.Add(N_UnitConfig, new Dictionary<string, dynamic>());
			Prop[N_UnitConfig].Add(N_UnitConfigPos, NodeVec3(0, 0, 0));
			Prop[N_UnitConfig].Add(N_UnitConfigRot, NodeVec3(0, 0, 0));
			Prop[N_UnitConfig].Add(N_UnitConfigScale, NodeVec3(1, 1, 1));
			Prop[N_UnitConfig].Add(N_UnitConfigModel, "");
			Prop[N_UnitConfig].Add(N_UnitConfigGenList, "Default");
			Prop[N_UnitConfig].Add(N_UnitConfigBaseClass, "");
			Prop[N_UnitConfig].Add(N_UnitConfigGenTarget, "Map");
		}

        public dynamic this [string name]
        {
            get
            {
                if (Prop.ContainsKey(name)) return Prop[name];
                else return null;
            }
            set
            {
                if (Prop.ContainsKey(name)) Prop[name] = value;
                else Prop.Add(name,value);
            }
        }

		public bool ContainsKey(string name) => Prop.ContainsKey(name);
		
		[DisplayName("Position")]
		[TypeConverter(typeof(PropertyGridTypes.Vector3DConverter))]
		[Category(" Transform")]
		public virtual Vector3D Pos
        {
            get { return new Vector3D(this[N_Translate]["X"], this[N_Translate]["Y"], this[N_Translate]["Z"]); }
            set {               

                this[N_Translate]["X"] = (Single)value.X;
                this[N_Translate]["Y"] = (Single)value.Y;
                this[N_Translate]["Z"] = (Single)value.Z;
            }
        }

		[System.ComponentModel.DisplayName("Rotation")]
		[TypeConverter(typeof(PropertyGridTypes.Vector3DConverter))]
		[Category(" Transform")]
		public Vector3D Rot
        {
            get { return new Vector3D(this[N_Rotate]["X"], this[N_Rotate]["Y"], this[N_Rotate]["Z"]); }
            set
            {
                this[N_Rotate]["X"] = (Single)value.X;
                this[N_Rotate]["Y"] = (Single)value.Y;
                this[N_Rotate]["Z"] = (Single)value.Z;
            }
        }

        [Browsable(false)]
        public int ID_int
        {
            get
            {
                int res = -1;
                if (ID.StartsWith("obj"))
                    int.TryParse(ID.Substring(3), out res);
                return res;
            }
			set
			{
				ID = "obj" + value.ToString();
			}
        }

        [Browsable(false)]
        public Vector3D ModelView_Pos
        {
            get => new Vector3D(this[N_Translate]["X"], -this[N_Translate]["Z"], this[N_Translate]["Y"]);
			set => Pos = new Vector3D(value.X, value.Z, -value.Y);
		}

        [Browsable(false)]
        public Vector3D ModelView_Rot
        {
            get { return new Vector3D(this[N_Rotate]["X"], -this[N_Rotate]["Z"], this[N_Rotate]["Y"]); } //TODO: check if it matches in-game
        }

		[System.ComponentModel.DisplayName("Scale")]
		[TypeConverter(typeof(PropertyGridTypes.Vector3DConverter))]
		[Category(" Transform")]
		public Vector3D Scale
        {
            get { return new Vector3D(this[N_Scale]["X"], this[N_Scale]["Y"], this[N_Scale]["Z"]); }
            set
            {
                this[N_Scale]["X"] = (Single)value.X;
                this[N_Scale]["Y"] = (Single)value.Y;
                this[N_Scale]["Z"] = (Single)value.Z;
            }
        }

        [Browsable(false)]
        public Vector3D ModelView_Scale
        {
            get { return new Vector3D(this[N_Scale]["X"], this[N_Scale]["Z"], this[N_Scale]["Y"]); }           
        }

        [Browsable(false)]
        public Transform transform
        {
            get => new Transform() { Pos = Pos, Rot = Rot, Scale = Scale };
            set
            {
                Pos = value.Pos;
                Rot = value.Rot;
                Scale = value.Scale;
            }
        }

        public string ID
        {
            get { return this[N_Id]; }
            set { this[N_Id] = value;}
        }

        public string Name
        {
            get { return this.ToString(); }
            set { this[N_Name] = value; }
        }

        public string ModelName
        {
            get => Prop.ContainsKey(N_ModelName) && Prop[N_ModelName] != null ? Prop[N_ModelName] : this.ToString();
        }

        public override string ToString()
        {
            string name = this[N_Name];
            if (name == null) name = "LevelObj id: " + this[N_Id];
            if (name == null) name = "LevelObj";
            return name;
        }

        public LevelObj Clone()
        {
            return new LevelObj(DeepCloneDictArr.DeepClone(Prop));
        }        

        object ICloneable.Clone()
        {
            return Clone();
        }
		
		static Dictionary<string,dynamic> NodeVec3(float x, float y, float z)
		{
			var res = new Dictionary<string, dynamic>();
			res.Add("X", (Single)x);
			res.Add("Y", (Single)y);
			res.Add("Z", (Single)z);
			return res;
		}
    }

    [Editor("OdysseyExt.LinksEditor", typeof(UITypeEditor))] //needs to be string to work (?)
    public class LinksNode : Dictionary<string, dynamic>, ICloneable //wrapper so we can use the custom editor
    {
        public LinksNode(Dictionary<string, dynamic> dict) : base(dict)
        {

        }

        public LinksNode() : base()
        {

        }

        public LinksNode Clone()
        {
            return new LinksNode(DeepCloneDictArr.DeepClone(this));
        }

        object ICloneable.Clone()
        {
            return Clone();
        }
    }

    public class LinksEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.Modal;
        }
        public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
        {
			LinksNode node = value as LinksNode;
			/*context should be of type System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry
			OwnerGrid is not a public property, we get it through reflection
			A reference to the parent form is needed to add the ObjList to the ListEditingStack*/
			Type t = context.GetType();
			if (!(t.GetProperty("OwnerGrid").GetValue(context, null) is PropertyGrid targetGrid))
				throw new Exception("context is not of the expected type");
			if (!(targetGrid.ParentForm is IEditorFormContext TargetForm))
				throw new Exception("context is not of the expected type");
			if (node != null)
			{
				using (var form = new EditorFroms.LinksEditor(node, TargetForm))
				{
					form.ShowDialog();
				}
			}
			return node;
		}
    }

    ///*
    //class LevelObjEditor : UITypeEditor
    //{
    //    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    //    {
    //        return UITypeEditorEditStyle.Modal;
    //    }
    //    public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
    //    {
    //        IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
    //        Dictionary<string, dynamic> v = value as Dictionary<string, dynamic>;
    //        if (svc != null && v != null)
    //        {
    //            using (FrmObjEditor form = new FrmObjEditor(v))
    //            {
    //                form.ShowDialog();
    //                v = form.Value.Prop;
    //            }
    //        }
    //        return v; // can also replace the wrapper object here
    //    }
    //}*/

    ////[Editor(typeof(C0ListEditor), typeof(UITypeEditor))]
    //public class C0List : ICloneable
    //{
    //    List<LevelObj> l = new List<LevelObj>();
    //    public List<LevelObj> List
    //    {
    //        get { return l; }
    //        set { l = value; }
    //    }

    //    public C0List Clone()
    //    {
    //        C0List C = new C0List();
    //        foreach (LevelObj lev in l) C.l.Add(lev.Clone());
    //        return C;
    //    }

    //    public override string ToString()
    //    {
    //        return "C0 list";
    //    }

    //    object ICloneable.Clone()
    //    {
    //        return Clone();
    //    }
    //}

    ///*
    //class C0ListEditor : UITypeEditor
    //{
    //    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    //    {
    //        return UITypeEditorEditStyle.Modal;
    //    }
    //    public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
    //    {
    //        IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
    //        C0List v = value as C0List;
    //        if (svc != null && v != null)
    //        {
    //            ((Form1)System.Windows.Forms.Application.OpenForms["Form1"]).EditC0List(v.List);
    //        }
    //        return v;
    //    }
    //}
    //*/

    //[TypeConverter(typeof(ExpandableObjectConverter))]
    //public class Rail : ICloneable
    //{
    //    public object this[string propertyName]
    //    {
    //        get { return this.GetType().GetProperty(propertyName).GetValue(this, null); }
    //        set { this.GetType().GetProperty(propertyName).SetValue(this, value, null); }
    //    }

    //    public Point3D[] GetPointArray()
    //    {
    //        List<Point3D> points = new List<Point3D>();
    //        foreach (Rail.Point p in Points) points.Add(new Point3D(p.X, -p.Z, p.Y));
    //        return points.ToArray();
    //    }

    //    List<int> _Args = new List<int>();
    //    string _LayerName;
    //    internal List<Point> _points = new List<Point>();
    //    //Multi file name ?
    //    public string _closed;
    //    int _l_id;
    //    string _name;
    //    int _no;
    //    string _type;

    //    public Rail(bool Adding = false, Vector3D? BasePosition = null)
    //    {
    //        _LayerName = "共通";
    //        _closed = "FALSE";
    //        _name = "empty rail";
    //        _type = "Bezier";
    //        if (Adding) _points.Add(new Point());
    //        if (Adding) _points.Add(new Point(1));
    //        if (BasePosition != null)
    //        {
    //            _points[0].X = (float)((Vector3D)BasePosition).X;
    //            _points[0].Y = (float)((Vector3D)BasePosition).Z;
    //            _points[0].Z = -(float)((Vector3D)BasePosition).Y;
    //            _points[1].X = (float)((Vector3D)BasePosition).X;
    //            _points[1].Y = (float)((Vector3D)BasePosition).Z;
    //            _points[1].Z = -(float)((Vector3D)BasePosition).Y;
    //        }
    //    }

    //    public override string ToString()
    //    {
    //        return _name;
    //    }

    //    public string Name
    //    {
    //        set
    //        {
    //            _name = JapChars(value);
    //        }
    //        get { return _name; }
    //    }

    //    public string Type
    //    {
    //        set { _type = value; }
    //        get { return _type; }
    //    }

    //    public bool Closed
    //    {
    //        set { _closed = value == false ? "OPEN" : "CLOSE"; }
    //        get { return _closed == "OPEN" ? false : true; }
    //    }

    //    public int no
    //    {
    //        set { _no = value; }
    //        get { return _no; }
    //    }

    //    public int l_id
    //    {
    //        set { _l_id = value; }
    //        get { return _l_id; }
    //    }        

    //    public List<int> Arg
    //    {
    //        set { _Args = value; }
    //        get { return _Args; }
    //    }

    //    internal string JapChars(string input)
    //    {
    //        byte[] bytes = Encoding.Default.GetBytes(input);
    //        Encoding Enc = Encoding.GetEncoding(932);
    //        return input;//Enc.GetString(bytes);
    //    }

    //    public Rail Clone()
    //    {

    //        Rail R = new Rail();
    //        foreach (int i in _Args) R._Args.Add(i);
    //        R.LayerName = (string)_LayerName.Clone();
    //        foreach (Point p in _points) R._points.Add(p.Clone());
    //        R._closed = (string)_closed.Clone();
    //        R.l_id = _l_id;
    //        R.Name = (string)_name.Clone();
    //        R.no = _no;
    //        R.Type = (string)_type.Clone();
    //        return R;
    //     }

    //    object ICloneable.Clone()
    //    {
    //        return Clone();
    //    }

    //    public string LayerName
    //    {
    //        set {
    //            _LayerName = JapChars(value);
    //        }
    //        get { return _LayerName; }
    //    }

    //   // [Editor(typeof(RailPointEditor), typeof(UITypeEditor))]
    //    public List<Point> Points
    //    {
    //        set { _points = value; }
    //        get { return _points; }
    //    }

    //    // [TypeConverter(typeof(ExpandableObjectConverter))]
    //    public class Point : ICloneable
    //    {
    //        List<int> _Args = new List<int>();
    //        int _ID;
    //        public List<Single> _X = new List<Single>();
    //        public List<Single> _Y = new List<Single>();
    //        public List<Single> _Z = new List<Single>();

    //        public Point(int id = 0)
    //        {
    //            _ID = id;
    //        }

    //        public override string ToString()
    //        {
    //            return "Point ID: " + _ID.ToString();
    //        }

    //        public Point Clone()
    //        {
    //            Point N = new Point();
    //            foreach (int i in _Args) N._Args.Add(i);
    //            N.ID = _ID;
    //            foreach (int s in _X) N._X.Add(s);
    //            foreach (int s in _Y) N._Y.Add(s);
    //            foreach (int s in _Z) N._Z.Add(s);
    //            return N;
    //        }

    //        public Point Clone_increment()
    //        {
    //            Point N = new Point();
    //            foreach (int i in _Args) N._Args.Add(i);
    //            N.ID = _ID + 1;
    //            foreach (int s in _X) N._X.Add(s + 100);
    //            foreach (int s in _Y) N._Y.Add(s);
    //            foreach (int s in _Z) N._Z.Add(s);
    //            return N;
    //        }

    //        object ICloneable.Clone()
    //        {
    //            return Clone();
    //        }

    //        public List<int> Args
    //        {
    //            set { _Args = value; }
    //            get { return _Args; }
    //        }

    //        public int ID
    //        {
    //            set { _ID = value; }
    //            get { return _ID; }
    //        }

    //        public Single X
    //        {
    //            set { _X.Clear(); _X.Add(value); _X.Add(value); _X.Add(value); }
    //            get {
    //                if (_X.Count == 0) X = 0;
    //                return _X[0];
    //            }
    //        }

    //        public Single Y
    //        {
    //            set { _Y.Clear(); _Y.Add(value); _Y.Add(value); _Y.Add(value); }
    //            get {
    //                if (_Y.Count == 0) Y = 0;
    //                return _Y[0];
    //            }
    //        }

    //        public Single Z
    //        {
    //            set { _Z.Clear(); _Z.Add(value); _Z.Add(value); _Z.Add(value); }
    //            get {
    //                if (_Z.Count == 0) Z = 0;
    //                return _Z[0];
    //            }
    //        }
    //    }
    //}
    ///*
    //class RailPointEditor : UITypeEditor
    //{
    //    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    //    {
    //        return UITypeEditorEditStyle.Modal;
    //    }
    //    public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
    //    {
    //        IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
    //        List<Rail.Point> v = value as List<Rail.Point>;
    //        if (svc != null && v != null)
    //        {
    //            using (FrmRailPointEditor form = new FrmRailPointEditor(v))
    //            {
    //                form.ShowDialog();
    //                v = form.Value;
    //            }
    //        }
    //        return v; // can also replace the wrapper object here
    //    }
    //}*/

    //[TypeConverter(typeof(ExpandableObjectConverter))]
    //class Node : ICloneable
    //{
    //    string _StringValue;
    //    public string _StringNodeType;
    //    NodeTypes _NodeType;

    //    [Description("This is the value of this node as a string, change it respecting the type")]
    //    public string StringValue
    //    {
    //        set
    //        {
    //            if (_NodeType == NodeTypes.Int) Int32.Parse(value); //Crashes if the value is invalid
    //            else if (_NodeType == NodeTypes.Single) Single.Parse(value);
    //            _StringValue = value;
    //        }
    //        get { return _StringValue; }
    //    }
    //    [Description("The node type can't be changed, it tells what kind of data contains the node")]
    //    public NodeTypes NodeType
    //    {
    //        //set { _NodeType = value; }
    //        get { return _NodeType; }
    //    }

    //    public override string ToString()
    //    {
    //        string Prev = "";
    //        if (_NodeType == NodeTypes.Empty) Prev += "Empty";
    //        else if (_NodeType == NodeTypes.String) Prev += "String";
    //        else if (_NodeType == NodeTypes.Int) Prev += "Int";
    //        else if (_NodeType == NodeTypes.Single) Prev += "Single";
    //        else Prev += string.Format("Unk Type ({0})", _StringNodeType);
    //        Prev += " : ";
    //        Prev += _StringValue;
    //        return Prev;
    //    }

    //    public enum NodeTypes
    //    {
    //        String = 0xA0,
    //        Empty = 0xA1,
    //        Int = 0xD1,
    //        Single = 0xD2,
    //        Other
    //    }

    //    string JapChars(string input)
    //    {
    //        byte[] bytes = Encoding.Default.GetBytes(input);
    //        Encoding Enc = Encoding.GetEncoding(932);
    //        return input; //Enc.GetString(bytes);
    //    }

    //    public Node(string _stringValue, string _type)
    //    {
    //        _NodeType = NodeTypes.Other;
    //        if (_type == "A0") _NodeType = NodeTypes.String;
    //        else if (_type == "A1") _NodeType = NodeTypes.Empty;
    //        else if (_type == "D1") _NodeType = NodeTypes.Int;
    //        else if (_type == "D2") _NodeType = NodeTypes.Single;
    //        _StringNodeType = _type;
    //        ApplyValue(_stringValue, _NodeType);
    //    }

    //    void ApplyValue(string _stringValue, NodeTypes _type)
    //    {
    //        _StringValue = _stringValue;
    //        switch (_type)
    //        {
    //            case NodeTypes.String:
    //                _StringValue = JapChars(_StringValue);
    //                _NodeType = NodeTypes.String;
    //                break;
    //            case NodeTypes.Empty:
    //                _NodeType = NodeTypes.Empty;
    //                break;
    //            default:
    //                _NodeType = _type;
    //                break;
    //        }
    //    }

    //    public Node Clone()
    //    {
    //        return new Node(this._StringValue, this._StringNodeType);
    //    }

    //    object ICloneable.Clone()
    //    {
    //        return Clone();
    //    }

    //    public static bool operator ==(Node first, Node second)
    //    {
    //        return first.NodeType == second.NodeType && first.StringValue == second.StringValue;
    //    }

    //    public static bool operator !=(Node first, Node second)
    //    {
    //        return first.NodeType != second.NodeType || first.StringValue != second.StringValue;
    //    }

    //    public override bool Equals(object Obj)
    //    {
    //        return (Node)Obj == this;
    //    }
    //}
    /*String = 0xA0,
      Empty = 0xA1,
      Int = 0xD1,
      Single = 0xD2,
      */

}