using MultiRepositories;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using CommandLine;
using Newtonsoft.Json;
using MultiRepositories.Repositories;
using System.Windows.Forms;
using System.Drawing;
using static System.Net.Mime.MediaTypeNames;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using Castle.Windsor;
using Castle.MicroKernel.Registration;
using System.Reflection;
using Ioc;
using Castle.MicroKernel.Resolvers.SpecializedResolvers;

namespace RepositoryCache
{
    class Program
    {
        static NotifyIcon notifyIcon = new NotifyIcon();
        static bool Visible = true;



        [DllImport("user32.dll")]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
        [DllImport("user32.dll")]
        static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
        public static void SetConsoleWindowVisibility(bool visible)
        {
            IntPtr hWnd = FindWindow(null, Console.Title);
            if (hWnd != IntPtr.Zero)
            {
                if (visible) ShowWindow(hWnd, 1); //1 = SW_SHOWNORMAL           
                else ShowWindow(hWnd, 0); //0 = SW_HIDE               
            }
        }

        static void Main(string[] args)
        {
            

            var options = new Options();
            Parser.Default.ParseArguments<Options>(args)
                .WithParsed<Options>(opts => RunOptionsAndReturnExitCode(opts))
                .WithNotParsed<Options>((errs) => HandleParseError(errs));
        }

        private static void HandleParseError(IEnumerable<Error> errs)
        {
            
        }

        static public string AssemblyDirectory
        {
            get
            {
                var codeBase = Assembly.GetExecutingAssembly().CodeBase;
                var uri = new UriBuilder(codeBase);
                var path = Uri.UnescapeDataString(uri.Path);
                var assemblyDir = Path.GetDirectoryName(path);
                return assemblyDir;
            }
        }

        private static void RunOptionsAndReturnExitCode(Options opts)
        {
            var settingsFile = opts.Settings;

            if (!string.IsNullOrWhiteSpace(settingsFile) && File.Exists(settingsFile))
            {
                Console.WriteLine("Reading settings from " + settingsFile);
                opts = JsonConvert.DeserializeObject<Options>(File.ReadAllText(settingsFile));
            }
            if (string.IsNullOrWhiteSpace(opts.Path))
            {
                opts.Path = Directory.GetCurrentDirectory();
            }
            opts.Settings = settingsFile;

            var settings = JsonConvert.SerializeObject(opts);
            Console.WriteLine(settings);

            if (opts.ShowInTray)
            {
                notifyIcon.DoubleClick += (s, e) =>
                {
                    Visible = !Visible;
                    SetConsoleWindowVisibility(Visible);
                };
                //notifyIcon.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
                Bitmap bmp = new Bitmap(16, 16, PixelFormat.Format24bppRgb);
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    g.FillEllipse(Brushes.Red, 0, 0, 16, 16);
                    g.FillRectangle(Brushes.White, 4, 6, 8, 4);
                }
                notifyIcon.Icon = FlimFlan.IconEncoder.Converter.BitmapToIcon(bmp);
                notifyIcon.Visible = true;
                notifyIcon.Text = "RepositoryCache";

                var contextMenu = new ContextMenuStrip();

                contextMenu.Items.Add("Exit", null, (s, e) => { System.Windows.Forms.Application.Exit(); });
                notifyIcon.ContextMenuStrip = contextMenu;

                SetConsoleWindowVisibility(false);
            }
            if (string.IsNullOrWhiteSpace(opts.Host))
            {
                opts.Host = "http://localhost:"+opts.Port;
            }


            var container = new WindsorContainer();

            RegisterApps(container, new AppProperties(opts.Host,"db"));
            var shttp= container.Resolve<ISimpleHTTPServer>();

            shttp.Start(opts.Path, opts.Port, opts.LogRequests, opts.Urls, opts.Ignores);

            if (opts.ShowInTray)
            {
                System.Windows.Forms.Application.Run();
            }
            else
            {
                while (Console.ReadKey().KeyChar != 'q')
                {
                    Console.WriteLine("");
                    continue;
                }
            }
            shttp.Stop();
        }

        private static void RegisterApps(WindsorContainer container, AppProperties appProperties)
        {
            //container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel));
            container.Kernel.Resolver.AddSubResolver(new ListResolver(container.Kernel,true));
            container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel,true));

            var filter = new AssemblyFilter(AssemblyDirectory);
            container.Register(
                Component.For<AppProperties>().Instance(appProperties));
            /*container.Register(
                Classes.FromAssemblyInDirectory(filter)
                    .BasedOn<AppProperties>());*/
            container.Register(
                Classes.FromAssemblyInDirectory(filter)
                    .BasedOn<ISingleton>()
                    .LifestyleSingleton()
                    .WithServiceAllInterfaces());
            container.Register(
                Classes.FromAssemblyInDirectory(filter)
                    .BasedOn<ITransient>()
                    .LifestyleTransient()
                    .WithServiceAllInterfaces());

        }
    }
}