using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;

namespace BizTalkCheckmkPulse.Tests
{
    internal static class Program
    {
        private static readonly List<string> Failures = new List<string>();
        private static int ExecutedTests;

        private static int Main()
        {
            Run("SelfTestEmitsAllStableServices", SelfTestEmitsAllStableServices);
            Run("UnavailableSourcesAreUnknown", UnavailableSourcesAreUnknown);
            Run("UnknownApplicationDoesNotCreateService", UnknownApplicationDoesNotCreateService);
            Run("KnownApplicationCreatesService", KnownApplicationCreatesService);
            Run("ServerNamesAreComparedWithoutWql", ServerNamesAreComparedWithoutWql);
            Run("GroupSettingQueryUsesDocumentedSchema", GroupSettingQueryUsesDocumentedSchema);
            Run("ProviderSqlLoginFailureIsPermission", ProviderSqlLoginFailureIsPermission);
            Run("RejectedSqlPrincipalIsExtracted", RejectedSqlPrincipalIsExtracted);
            Run("PlatformPermissionPropagatesToSqlDiscovery", PlatformPermissionPropagatesToSqlDiscovery);

            if (Failures.Count == 0)
            {
                Console.WriteLine("PASS: " + ExecutedTests + " tests");
                return 0;
            }

            foreach (var failure in Failures)
            {
                Console.Error.WriteLine("FAIL: " + failure);
            }

            return 1;
        }

        private static void SelfTestEmitsAllStableServices()
        {
            var lines = new CheckmkLocalFormatter(new MonitoringOptions()).FormatSelfTest().ToArray();
            AssertEqual(6, lines.Length, "self-test line count");
            AssertEqual(6, lines.Distinct(StringComparer.Ordinal).Count(), "unique self-test lines");
            Assert(lines.All(x => x.StartsWith("0 \"BizTalk ", StringComparison.Ordinal)), "every self-test line must be OK");
            Assert(lines.Any(x => x.Contains("\"BizTalk Event Log\"")), "Event Log service missing");
        }

        private static void UnavailableSourcesAreUnknown()
        {
            var lines = new CheckmkLocalFormatter(new MonitoringOptions()).Format(new ProbeResult()).Take(6).ToArray();
            AssertEqual(6, lines.Length, "stable service count");
            Assert(lines.All(x => x.StartsWith("3 \"BizTalk ", StringComparison.Ordinal)), "unavailable sources must be UNKNOWN");
        }

        private static void UnknownApplicationDoesNotCreateService()
        {
            var options = new MonitoringOptions { EmitPerApplicationSuspensionServices = true };
            var result = CreateSuspensionResult("(unknown)");
            var lines = new CheckmkLocalFormatter(options).Format(result).ToArray();
            AssertEqual(6, lines.Length, "unknown application must not create a dynamic service");
        }

        private static void KnownApplicationCreatesService()
        {
            var options = new MonitoringOptions { EmitPerApplicationSuspensionServices = true };
            var result = CreateSuspensionResult("Orders");
            var lines = new CheckmkLocalFormatter(options).Format(result).ToArray();
            AssertEqual(7, lines.Length, "known application should create one dynamic service");
            Assert(lines.Any(x => x.Contains("\"BizTalk Suspended Orders\"")), "known application service missing");
        }

        private static void ServerNamesAreComparedWithoutWql()
        {
            Assert(WmiBizTalkProbe.IsSameServer("BIZTALK01.corp.example", "biztalk01"), "FQDN and short name must match");
            Assert(WmiBizTalkProbe.IsSameServer(@"\\BIZ-TALK+01", "biz-talk+01.example"), "special characters must be compared client-side");
            Assert(!WmiBizTalkProbe.IsSameServer("BIZTALK01", "BIZTALK02"), "different servers must not match");
        }

        private static void GroupSettingQueryUsesDocumentedSchema()
        {
            var query = WmiBizTalkProbe.GroupSettingQuery;
            Assert(query.Contains("FROM MSBTS_GroupSetting"), "MSBTS_GroupSetting query missing");
            Assert(query.Contains("BizTalkOperatorGroup"), "configured operator group property missing");
            Assert(query.Contains("SubscriptionDBServerName"), "master MessageBox server property missing");
            Assert(query.Contains("SubscriptionDBName"), "master MessageBox database property missing");
            Assert(query.IndexOf("MessageBoxSetting", StringComparison.OrdinalIgnoreCase) < 0, "unsupported MessageBoxSetting class present");
        }

        private static void ProviderSqlLoginFailureIsPermission()
        {
            var exception = new COMException(
                "Internal error from OLEDB provider: 'Login failed for user 'BEW\\AV23AGPWBIO1$'.'",
                unchecked((int)0x80131904));
            AssertEqual(
                DiagnosticCategory.Permission,
                WmiBizTalkProbe.ClassifyWmiException(exception),
                "provider SQL login classification");
        }

        private static void RejectedSqlPrincipalIsExtracted()
        {
            var message = "Internal error from OLEDB provider: 'Login failed for user 'BEW\\AV23AGPWBIO1$'.'";
            AssertEqual(
                "BEW\\AV23AGPWBIO1$",
                WmiBizTalkProbe.ExtractSqlLoginPrincipal(message),
                "rejected SQL principal");
        }

        private static void PlatformPermissionPropagatesToSqlDiscovery()
        {
            var result = new ProbeResult();
            result.Diagnostics.Add(new ProbeDiagnostic
            {
                Area = DiagnosticArea.Wmi,
                Category = DiagnosticCategory.Permission,
                Component = "MSBTS_GroupSetting",
                Required = true
            });

            new SqlConnectivityProbe(new MonitoringOptions()).Query(result);

            var discovery = result.Diagnostics.Single(x =>
                x.Area == DiagnosticArea.Sql
                && x.Component == "BizTalk database discovery");
            AssertEqual(
                DiagnosticCategory.Permission,
                discovery.Category,
                "SQL discovery classification");
        }

        private static ProbeResult CreateSuspensionResult(string applicationName)
        {
            var result = new ProbeResult();
            result.Platform.SuspendedInstancesDataAvailable = true;
            result.SuspendedInstances.Add(new SuspendedInstance
            {
                ApplicationName = applicationName,
                ServiceName = "TestService",
                Kind = SuspendedKind.Resumable
            });
            return result;
        }

        private static void Run(string name, Action test)
        {
            ExecutedTests++;
            try
            {
                test();
            }
            catch (Exception ex)
            {
                Failures.Add(name + ": " + ex.Message);
            }
        }

        private static void Assert(bool condition, string message)
        {
            if (!condition)
            {
                throw new InvalidOperationException(message);
            }
        }

        private static void AssertEqual(int expected, int actual, string label)
        {
            if (expected != actual)
            {
                throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
            }
        }

        private static void AssertEqual(DiagnosticCategory expected, DiagnosticCategory actual, string label)
        {
            if (expected != actual)
            {
                throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
            }
        }

        private static void AssertEqual(string expected, string actual, string label)
        {
            if (!string.Equals(expected, actual, StringComparison.Ordinal))
            {
                throw new InvalidOperationException(label + ": expected " + expected + ", actual " + actual);
            }
        }
    }
}