﻿/*
 *  TOPPERS/ECNL Prototyping tool
 *
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 *
 *  上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
 *      免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  の責任を負わない．
 *
 *  @(#) $Id$
 */
using System;
using System.Collections.Generic;
using System.Linq;
using Bridge;
using Bridge.Html5;
using Bridge.jQuery2;

namespace WebMrbc
{
	delegate bool jQueryKeyboardHandler(jQueryKeyboardEvent e);

	public static class App
	{
		public static Mruby Module;
		public static Terminal Term;
		public static AceEditor CodeEditor;
		public static TargetBoard TargetBoard;
		public static bool changedAfterTranslating;
		public static bool translating;
		public static JsonClassInfo NodeProfileClass;
		public static JsonClassGroupInfo[] ClassGroups;
		public static JsonPropertyInfo[] BaseObjectPropertyList;
		public static string ArduinoToolbox;
		public static string EcnlToolbox;

		[Ready]
		public static void Main()
		{
			Script.Write("Number.isFinite = Number.isFinite || function(any) { return typeof any === 'number' && isFinite(any); }");
			Script.Write("Number.isNaN = Number.isNaN || function(any) { return typeof any === 'number' && isNaN(any); }");

			App.TargetBoard = new GrPeach();
			Collections.ClassWorkspaces = new Collection<IClassWorkspace>();
			Views.ClassSelectorView = new ClassSelectorView();
			Views.ClassSelectorView.SetCollection(Collections.ClassWorkspaces);
			Views.EObjectModalView = new EObjectModalView();
			Views.MainMenuView = new MainMenuView();

			var termElement = Document.GetElementById("term");
			Term = new Terminal(new TerminalOption() {
				cols = 80,
				rows = 24,
				useStyle = true,
				screenKeys = true,
				cursorBlink = false
			});
			Term.on("data", new Action<object>((data) => {
				if (Module != null && Module["stdin"] != null)
					Module.stdin(data);
			}));
			Term.on("title", new Action<string>((title) => {
				Document.Title = title;
			}));

			Term.open(termElement);

			CodeEditor = ace.edit("text-editor");
			Window.Set("textEditor", CodeEditor);
			CodeEditor.setTheme("ace/theme/twilight");
			CodeEditor.setShowInvisibles(true);
			CodeEditor.gotoLine(0, 0);
			CodeEditor.On("change", new Action(() => {
				if (!translating) {
					changedAfterTranslating = true;
				}
			}));
			var session = CodeEditor.getSession();
			session.setMode("ace/mode/ruby");
			session.setTabSize(2);
			session.setUseSoftTabs(false);

			var statusElement = Document.GetElementById("status");
			var progressElement = Document.GetElementById("progress");
			var spinnerElement = Document.GetElementById("spinner");

			statusElement.InnerHTML = "Downloading...";

			jQuery.Ready(() => {
				InitClassGroups((result) => {
					if (result) {
						Views.EObjectModalView.InitClassGroups();
					}
					InitArduinoToolbox((result1) => {
						InitEcnlToolbox((result2) => {
							if (result1 && result2) {
								AddMainLoop();
								AddEcnlTask();
								AddENode();
							}
							statusElement.InnerHTML = "";
							spinnerElement.Style.Display = Display.None;
						});
					});
				});
			});
		}

		public static void InitClassGroups(Action<bool> action)
		{
			jQuery.Ajax(new AjaxOptions() {
				Url = "echonet_objects.json",
				Success = (data, textStatus, request) => {
					ClassGroupsSuccess(data, textStatus, request);
					action?.Invoke(true);
				},
				Error = (request, textStatus, error) => {
					AjaxError(request, textStatus, error);
					action?.Invoke(false);
				}
			});
		}

		private static void ClassGroupsSuccess(object data, string textStatus, jqXHR request)
		{
			var _deviceInfo = (dynamic)((data.GetType() == typeof(string)) ? jQuery.ParseJSON((string)data) : data);
			var profProps = new JsonPropertyInfo[0];
			foreach (var property in _deviceInfo.baseProfilePropertyList) {
				profProps.Push(new JsonPropertyInfo(property));
			}
			var objProps = new JsonPropertyInfo[0];
			foreach (var property in _deviceInfo.baseObjectPropertyList) {
				objProps.Push(new JsonPropertyInfo(property));
			}
			BaseObjectPropertyList = objProps;

			var classGroups = new JsonClassGroupInfo[0];
			foreach (var _item in _deviceInfo.classGroupList) {
				var item = new JsonClassGroupInfo(_item);
				classGroups.Push(item);
				var classes = new JsonClassInfo[0];
				foreach (var _cls in _item.classList) {
					var cls = new JsonClassInfo(_cls);
					cls.classGroup = item;
					classes.Push(cls);
					var properties = new JsonPropertyInfo[0];
					foreach (var property in _cls.propertyList) {
						properties.Push(new JsonPropertyInfo(property));
					}
					if ((item.classGroupCode == 0xE) && (cls.classCode == 0xF0)) {
						cls.properties = profProps.Concat(properties).ToArray();
						NodeProfileClass = cls;
					}
					else {
						cls.properties = properties;
					}
				}
				item.classes = classes;
			}
			ClassGroups = classGroups;
		}

		public static void InitArduinoToolbox(Action<bool> action)
		{
			jQuery.Ajax(new AjaxOptions() {
				Url = "arduino_toolbox.xml",
				DataType = "text",
				Success = (data, textStatus, request) => {
					ArduinoToolbox = (string)data;
					action?.Invoke(true);
				},
				Error = (request, textStatus, error) => {
					AjaxError(request, textStatus, error);
					action?.Invoke(false);
				}
			});
		}

		public static void InitEcnlToolbox(Action<bool> action)
		{
			jQuery.Ajax(new AjaxOptions() {
				Url = "ecnl_toolbox.xml",
				DataType = "text",
				Success = (data, textStatus, request) => {
					EcnlToolbox = (string)data;
					action?.Invoke(true);
				},
				Error = (request, textStatus, error) => {
					AjaxError(request, textStatus, error);
					action?.Invoke(false);
				}
			});
		}

		private static void AjaxError(jqXHR request, string textStatus, string error)
		{
		}

		/// <summary>
		/// テキスト入力欄のEnter(Return)キーを無視する
		/// </summary>
		/// <param name="el"></param>
		/// <returns></returns>
		static jQuery ignoreEnterKey(jQuery el)
		{
			return el.Find("input[type=text]").KeyPress(new jQueryKeyboardHandler((e) => {
				if (e == null)
					e = (jQueryKeyboardEvent)Window.Get("Event");
				if (e.KeyCode == 13)
					return false;
				else
					return true;
			}));
		}

		private static void AddMainLoop()
		{
			var view = Views.MainMenuView.NewBlocklyView("MainLoop");
			var workspace = new MainLoopWorkspace(view);
			Collections.MainLoopWorkspace = workspace;
			Collections.ClassWorkspaces.Add(workspace);
			Views.ClassSelectorView.SelectClassWorkspace(workspace);
			view.ReloadToolbox(workspace);
		}

		private static void AddEcnlTask()
		{
			var identifier = Collections.ClassWorkspaces.UniqueName("EcnlTask");
			var view = Views.MainMenuView.NewBlocklyView(identifier);
			var workspace = new EcnlTaskWorkspace(view);
			Collections.EcnlTaskWorkspace = workspace;
			Collections.ClassWorkspaces.Add(workspace);
			Views.ClassSelectorView.SelectClassWorkspace(workspace);
			view.ReloadToolbox(workspace);
		}

		private static void AddENode()
		{
			var identifier = Collections.ClassWorkspaces.UniqueName("LocalNode");
			var localNode = new JsonNodeInfo(NodeProfileClass, identifier, "local");
			var properties = new JsonPropertyInfo[0];
			foreach (var item in localNode.type.properties) {
				if ((item.required.Length > 0) && (item.required[0] != "NONE")) {
					properties.Push(new JsonPropertyInfo(item));
				}
			}
			localNode.properties = properties;
			var view = Views.MainMenuView.NewBlocklyView(localNode.identifier);
			var workspace = new ENodeWorkspace(view, localNode);
			Collections.LocalNode = workspace;
			Collections.ClassWorkspaces.Add(workspace);
			Views.ClassSelectorView.SelectClassWorkspace(workspace);
			view.BlockCreated += workspace.OnBlockCreated;
			view.BlockDeleted += workspace.OnBlockDeleted;
			view.BlockChanged += workspace.OnBlockChanged;
			view.BlockMoveed += workspace.OnBlockMoveed;
			view.ReloadToolbox(workspace);
		}

		internal static void NewItem(Action<IClassWorkspace> callback)
		{
			var identifier = Collections.ClassWorkspaces.UniqueName("Kaden");
			var eobject = new JsonObjectInfo(App.NodeProfileClass, identifier);
			var properties = new JsonPropertyInfo[0];
			if ((eobject.type.classGroup.classGroupCode != 0x0E)
				&& (eobject.type.classCode != 0xF0)) {
				foreach (var item in App.BaseObjectPropertyList) {
					if ((item.required.Length > 0) && (item.required[0] != "NONE")) {
						properties.Push(new JsonPropertyInfo(item));
					}
				}
			}
			foreach (var item in eobject.type.properties) {
				if ((item.required.Length > 0) && (item.required[0] != "NONE")) {
					properties.Push(new JsonPropertyInfo(item));
				}
			}
			eobject.properties = properties;
			var view = Views.MainMenuView.NewBlocklyView(eobject.identifier);
			var workspace = new EObjectWorkspace(view, eobject);
			view.BlockCreated += workspace.OnBlockCreated;
			view.BlockDeleted += workspace.OnBlockDeleted;
			view.BlockChanged += workspace.OnBlockChanged;
			view.BlockMoveed += workspace.OnBlockMoveed;
			callback(workspace);
		}

		internal static void RemoveItem(IClassWorkspace item)
		{
			Views.MainMenuView.RemoveEObjectWorkspace(item);
		}

		internal static void Write(string text)
		{
			Term?.write(text.Replace("\n", "\r\n"));
		}

		internal static void WriteLine(string text)
		{
			Term?.write(text.Replace("\n", "\r\n") + "\r\n");
		}
	}

	public interface IClassWorkspace : IModel
	{
		Workspace Workspace { get; }
		BlocklyView View { get; }
		Ruby RubyCode { get; }
		string GetImageUrl();
		bool IsPreset();
		string ToCode(string filename);
		void Activate();
		void Inactivate();
		void ReloadToolbox(HTMLElement toolbox);
		void OpenModifyView(Action<bool> callback);
		string Template(string template);
	}

	public class Collections
	{
		[Convention(Notation.PascalCase)]
		internal static ENodeWorkspace LocalNode;
		[Convention(Notation.PascalCase)]
		internal static Collection<IClassWorkspace> ClassWorkspaces;
		[Convention(Notation.PascalCase)]
		internal static EcnlTaskWorkspace EcnlTaskWorkspace;
		[Convention(Notation.PascalCase)]
		internal static MainLoopWorkspace MainLoopWorkspace;
	}

	public class Views
	{
		[Convention(Notation.PascalCase)]
		internal static MainMenuView MainMenuView;
		[Convention(Notation.PascalCase)]
		internal static ClassSelectorView ClassSelectorView;
		[Convention(Notation.PascalCase)]
		internal static EObjectModalView EObjectModalView;
	}

	public class HexDump
	{
		string text;

		public HexDump(Uint8Array bytes, int width)
		{
			var sb = new string[0];

			for (int index = 0; index < bytes.Length; index += width) {
				sb.Push(String.Format("{0:X4} : ", index)
					+ BinBump(bytes, index, width)
					+ AsciiDump(bytes, index, width));
			}

			text = sb.Join("\n");
		}

		private string BinBump(Uint8Array bytes, int offset, int width)
		{
			var sb = new System.Text.StringBuilder();

			for (int index = 0; index < width; index++) {
				if (index + offset < bytes.Length) {
					sb.AppendFormat("{0:X2} ", bytes[index + offset]);
				}
				else {
					sb.Append("   ");
				}
			}

			return sb.ToString();
		}

		private string AsciiDump(Uint8Array bytes, int index, int width)
		{
			var sb = "";

			if (index < bytes.Length) {
				width = System.Math.Min(width, bytes.Length - index);

				sb += ": ";
				for (int i = 0; i < width; i++) {
					byte b = bytes[i + index];
					if (b < 0x20)
						sb += "\x1B[1;3;31m" + StringPrototype.FromCharCode(b + 0x40) + "\x1B[0m";
					else
						sb += StringPrototype.FromCharCode(b);
				}
			}
			else {
				sb += ":         ";
			}

			return sb;
		}

		public override string ToString()
		{
			return text;
		}
	}
}
