using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using ElmSharp;
using Tizen.Applications;
using TSystemInfo = Tizen.System.SystemInfo;

namespace Xamarin.Forms.Platform.Tizen
{
	public static class Forms
	{
		static Lazy<int> s_dpi = new Lazy<int>(() =>
		{
			int dpi = 0;
			TSystemInfo.TryGetValue<int>("http://tizen.org/feature/screen.dpi", out dpi);
			return dpi;
		});
		class TizenDeviceInfo : DeviceInfo
		{
			readonly Size pixelScreenSize;

			readonly Size scaledScreenSize;

			readonly double scalingFactor;

			readonly string profile;

			public override Size PixelScreenSize
			{
				get
				{
					return this.pixelScreenSize;
				}
			}

			public override Size ScaledScreenSize
			{
				get
				{
					return this.scaledScreenSize;
				}
			}

			public override double ScalingFactor
			{
				get
				{
					return this.scalingFactor;
				}
			}

			public string Profile
			{
				get
				{
					return this.profile;
				}
			}

			public TizenDeviceInfo(FormsApplication formsApplication)
			{
				int width = 0;
				int height = 0;

				TSystemInfo.TryGetValue("http://tizen.org/feature/screen.width", out width);
				TSystemInfo.TryGetValue("http://tizen.org/feature/screen.height", out height);

				scalingFactor = 1.0;  // scaling is disabled, we're using pixels as Xamarin's geometry units
				pixelScreenSize = new Size(width, height);
				scaledScreenSize = new Size(width / scalingFactor, height / scalingFactor);

				//TODO : Fix me if elm_config_profile_get() unavailable
				profile = Elementary.GetProfile();
			}
		}

		public static event EventHandler<ViewInitializedEventArgs> ViewInitialized;

		public static FormsApplication Context
		{
			get;
			internal set;
		}

		public static bool IsInitialized
		{
			get;
			private set;
		}

		internal static TizenTitleBarVisibility TitleBarVisibility
		{
			get;
			private set;
		}

		internal static void SendViewInitialized(this VisualElement self, EvasObject nativeView)
		{
			EventHandler<ViewInitializedEventArgs> viewInitialized = Forms.ViewInitialized;
			if (viewInitialized != null)
			{
				viewInitialized.Invoke(self, new ViewInitializedEventArgs
				{
					View = self,
					NativeView = nativeView
				});
			}
		}

		public static void SetTitleBarVisibility(TizenTitleBarVisibility visibility)
		{
			TitleBarVisibility = visibility;
		}

		public static void Init(FormsApplication application)
		{
			SetupInit(application);
		}

		static void SetupInit(FormsApplication application)
		{
			Color.Accent = GetAccentColor();

			Context = application;

			if (!IsInitialized)
			{
				Xamarin.Forms.Log.Listeners.Add(new XamarinLogListener());
				if (System.Threading.SynchronizationContext.Current == null)
				{
					TizenSynchronizationContext.Initialize();
				}
				Elementary.Initialize();
				Elementary.ThemeOverlay();
			}

			Device.OS = TargetPlatform.Tizen;

			// In .NETCore, AppDomain feature is not supported.
			// The list of assemblies returned by AppDomain.GetAssemblies() method should be registered manually.
			// The assembly of the executing application and referenced assemblies of it are added into the list here.
			Assembly asm = application.GetType().GetTypeInfo().Assembly;
			TizenPlatformServices.AppDomain.CurrentDomain.RegisterAssembly(asm);
			foreach (var refName in asm.GetReferencedAssemblies())
			{
				if (!refName.Name.StartsWith("System.") && !refName.Name.StartsWith("Microsoft."))
				{
					try
					{
						Assembly refAsm = Assembly.Load(refName);
						TizenPlatformServices.AppDomain.CurrentDomain.RegisterAssembly(refAsm);
					}
					catch
					{
						Log.Warn("Reference Assembly can not be loaded. {0}", refName.FullName);
					}
				}
			}

			Device.PlatformServices = new TizenPlatformServices(); ;
			if (Device.info != null)
			{
				((TizenDeviceInfo)Device.info).Dispose();
				Device.info = null;
			}

			Device.Info = new Forms.TizenDeviceInfo(application);

			if (!Forms.IsInitialized)
			{
				Registrar.RegisterAll(new Type[]
				{
					typeof(ExportRendererAttribute),
					typeof(ExportImageSourceHandlerAttribute),
					typeof(ExportCellAttribute),
				});
			}

			// TODO: We should consider various tizen profiles such as TV, Wearable and so on.
			string profile = ((TizenDeviceInfo)Device.Info).Profile;
			if (profile == "mobile")
			{
				Device.Idiom = TargetIdiom.Phone;
			}
			else if (profile == "tv" || profile == "desktop")
			{
				Device.Idiom = TargetIdiom.Desktop;
			}
			else
			{
				Device.Idiom = TargetIdiom.Unsupported;
			}

			ExpressionSearch.Default = new TizenExpressionSearch();
			IsInitialized = true;
		}

		static Color GetAccentColor()
		{
			// On Windows Phone, this is the complementary color chosen by the user.
			// Good Windows Phone applications use this as part of their styling to provide a native look and feel.
			// On iOS and Android this instance is set to a contrasting color that is visible on the default
			// background but is not the same as the default text color.

			// TODO: implement me
			return Color.Black;
		}

		internal static int ConvertToPixel(double dp)
		{
			return (int)Math.Round(dp * s_dpi.Value / 160.0);
		}
	}

	class TizenExpressionSearch : ExpressionVisitor, IExpressionSearch
	{
		List<object> _results;
		Type _targetType;

		public List<T> FindObjects<T>(Expression expression) where T : class
		{
			_results = new List<object>();
			_targetType = typeof(T);
			Visit(expression);
			return _results.Select(o => o as T).ToList();
		}

		protected override Expression VisitMember(MemberExpression node)
		{
			if (node.Expression is ConstantExpression && node.Member is FieldInfo)
			{
				var container = ((ConstantExpression)node.Expression).Value;
				var value = ((FieldInfo)node.Member).GetValue(container);

				if (_targetType.IsInstanceOfType(value))
					_results.Add(value);
			}
			return base.VisitMember(node);
		}
	}
}