// /**
//  * File: CrawlHost.cs
//  * Author: haraldwolff
//  *
//  * This file and it's content is copyrighted by the Author and / or copyright holder.
//  * Any use wihtout proper permission is illegal and may lead to legal actions.
//  *
//  *
//  **/
using System;
using ln.types.threads;
using ln.logging;
using System.Net.NetworkInformation;
using ln.snmp.endpoint;
using ln.snmp;
using System.Net;
using ln.snmp.types;
using System.Collections.Generic;
using ln.snmp.rfc1213;
using ln.types;
using ln.skyscanner.crawl.tests;
using System.Runtime.Remoting.Messaging;
using ln.skyscanner.crawl.service;
using ln.types.net;
namespace ln.skyscanner.crawl
{
    public class Crawl : PoolJob
    {
        public Crawler Crawler { get; }
        public CrawledHost Host { get; }

        List<CrawlService> servicesToCheck = new List<CrawlService>();
        List<CrawlService> servicesChecked = new List<CrawlService>();

        public CrawlService CurrentService { get; set; }

        public Crawl(Crawler crawler,CrawledHost crawledHost)
        {
            Crawler = crawler;
            Host = crawledHost;

            servicesToCheck.AddRange(CrawlService.Services);

            Name = String.Format("Crawl: {0} [ {1} ]", crawledHost.Name, crawledHost.PrimaryIP);
        }

        public void UpdateState(CrawlService currentService,double progress)
        {
            double progBase = (double)servicesChecked.Count / (double)(servicesChecked.Count + servicesToCheck.Count);
            State = String.Format("Service: {0} => {1:F1}%", currentService?.Name, progress * 100.0);
            CurrentService = currentService;
            Progress = progBase;
        }


        public bool CheckRequiredOption(string serviceName,params object[] parameters)
        {
            foreach (CrawlService service in servicesChecked)
            {
                if (service.Name.Equals(serviceName))
                {
                    return service.HostProvidesOption(this,parameters);
                }
            }
            foreach (CrawlService service in servicesToCheck)
            {
                if (service.Name.Equals(serviceName))
                {
                    RunServiceCheck(service);
                    return service.HostProvidesOption(this,parameters);
                }
            }
            return false;
        }


        private void RunServiceCheck(CrawlService crawlService)
        {
            CrawlService lastService = CurrentService;

            UpdateState(crawlService, 0);

            crawlService.Check(this);

            UpdateState(crawlService, 1.0);

            servicesChecked.Add(crawlService);
            servicesToCheck.Remove(crawlService);

            CurrentService = lastService;
        }

        public override void RunJob()
        {
            State = "Prepare";

            DateTime dateTime = DateTime.Now;

            try
            {
                while (servicesToCheck.Count > 0)
                    RunServiceCheck(servicesToCheck[0]);
            } catch (Exception e)
            {
                Logging.Log(LogLevel.ERROR, "Crawl.RunJob(): Caught exception: {0}",e);
                Logging.Log(e);
            }

            Host.LastCheckTime = DateTime.Now - dateTime;
            Host.LastCheck = dateTime;
            Host.NextCheck = dateTime + TimeSpan.FromHours(24);

            bool updated = SkyScanner.Instance.Entities.CrawledHosts.Upsert( Host );

            foreach (Network4 network in Host.Networks)
                Crawler.EnsureSubnet(network);

            setState("Updating global network");
            SkyScanner.Instance.Entities.GlobalNetwork.EnqueueUpdate(Host);
        }

        public override int GetHashCode()
        {
            return Host.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is Crawl)
            {
                Crawl you = obj as Crawl;
                return Crawler.Equals(you.Crawler) &&  Host.Equals(you.Host);
            }
            return false;
        }
    }
}