using System;

using System.ComponentModel;

using System.Diagnostics;

using System.Runtime.CompilerServices;

using System.Threading.Tasks;

using DesertPaintCodex.Services;

using JetBrains.Annotations;

namespace DesertPaintCodex.Models

{

    public class ReactionTest : INotifyPropertyChanged, IProgress<float>, IComparable<ReactionTest>

    {

        public enum TestState

        {

            Unset = -1,

            Untested,

            Scanning,

            LabNotFound,

            ClippedResult,

            GoodResult,

            Saved

        }

        public Reagent Reagent1 { get; }

        public Reagent Reagent2 { get; }

        {

            set

            {

                }

                {

                NotifyPropertyChanged(nameof(CanScan));

            }

        }

        private ClipType _clipType;

        public ClipType Clipped {

            get => _clipType;

            set

            {

                _clipType = value;

                NotifyPropertyChanged(nameof(Clipped));

            }

        }

        public bool IsAllCatalysts { get; }

        private Reaction? _reaction;

        public Reaction? Reaction { get => _reaction; set { _reaction = value; NotifyPropertyChanged(nameof(Reaction)); } }

        private Reaction? _badReaction;

        public Reaction? BadReaction { get => _badReaction; set { _badReaction = value; NotifyPropertyChanged(nameof(BadReaction)); } }

        private int _scanProgress;

        public int ScanProgress { get => _scanProgress; set { _scanProgress = value; NotifyPropertyChanged(nameof(ScanProgress)); } }

        private TestState _state;

        public TestState State

        {

            get => _state;

            set

            {

                _state = value;

                NotifyPropertyChanged(nameof(State));

                NotifyPropertyChanged(nameof(Requires3Way));

                NotifyPropertyChanged(nameof(CanScan));

                NotifyPropertyChanged(nameof(IsScanning));

                NotifyPropertyChanged(nameof(HasResults));

                NotifyPropertyChanged(nameof(HasReaction));

                NotifyPropertyChanged(nameof(CanClear));

                NotifyPropertyChanged(nameof(CanSave));

                NotifyPropertyChanged(nameof(NoLab));

                NotifyPropertyChanged(nameof(CanPickBuffer));

            }

        }

        public bool Requires3Way =>

            (State == TestState.ClippedResult) || IsAllCatalysts;

        public bool IsScanning => State == TestState.Scanning;

        public bool HasResults => (ObservedColor != null) && (State is TestState.ClippedResult or TestState.GoodResult or TestState.LabNotFound);

        public bool HasReaction => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;

        public bool CanClear => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;

        public bool CanSave => State == TestState.GoodResult;

        public bool NoLab => State == TestState.LabNotFound;

        public bool CanPickBuffer => (State == TestState.ClippedResult) || IsAllCatalysts;

        private PaintColor? _hypotheticalColor;

        public PaintColor? HypotheticalColor { get => _hypotheticalColor; set { _hypotheticalColor = value; NotifyPropertyChanged(nameof(HypotheticalColor)); } }

        private PaintColor? _observedColor;

        public PaintColor? ObservedColor { get => _observedColor; set { _observedColor = value; NotifyPropertyChanged(nameof(ObservedColor)); } }

        private readonly PaintRecipe _recipe = new();

        public bool IsStub { get; }

        public ReactionTest(Reagent reagent1, Reagent reagent2, Reaction? reaction, ClipType clipType, bool isStub = false)

        {

            Reagent1 = reagent1;

            Reagent2 = reagent2;

            IsAllCatalysts = reagent1.IsCatalyst && reagent2.IsCatalyst;

            Clipped = clipType;

            Reaction = reaction;

            State = (reaction != null) ? TestState.Saved :

                (clipType == ClipType.None) ? TestState.Untested : TestState.ClippedResult;

            _recipe.AddReagent(reagent1.Name);

            _recipe.AddReagent(reagent2.Name);

            IsStub = isStub;

            UpdateHypotheticalColor();

        }

        #region Actions

        public async Task StartScan()

        {

            Clipped = ClipType.None;

            ScanProgress = 0;

            Reaction = null;

            BadReaction = null;

            State = TestState.Scanning;

            bool foundLab = await ReactionScannerService.Instance.CaptureReactionAsync(this);

            if (foundLab)

            {

                ObservedColor = ReactionScannerService.Instance.RecordedColor;

                if (_observedColor != null)

                {

                    Clipped = _observedColor.Red switch

                        {

                            0   => ClipType.RedLow,

                            255 => ClipType.RedHigh,

                            _   => ClipType.None

                        }

                        | _observedColor.Green switch

                        {

                            0   => ClipType.GreenLow,

                            255 => ClipType.GreenHigh,

                            _   => ClipType.None

                        }

                        | _observedColor.Blue switch

                        {

                            0   => ClipType.BlueLow,

                            255 => ClipType.BlueHigh,

                            _   => ClipType.None

                        };

                    if (Clipped == ClipType.None)

                    {

                        State = TestState.GoodResult;

                        Reaction = CalculateReaction();

                    }

                    else

                    {

                        State = TestState.ClippedResult;

                        BadReaction = CalculateReaction();

                    }

                    PlayerProfile? profile = ProfileManager.CurrentProfile;

                    profile?.SetPairClipStatus(Reagent1, Reagent2, Clipped);

                }

            }

            else

            {

                Debug.WriteLine("ERROR: Lab UI not found.");

                State = TestState.LabNotFound;

            }

        }

        public void CancelScan()

        {

            ReactionScannerService.Instance.CancelScan();

            State = TestState.Untested;

        }

        public void MarkInert()

        {

            Reaction = new Reaction(0, 0, 0);

            State = TestState.GoodResult;

        }

        public void ClearReaction()

        {

            PlayerProfile? profile = ProfileManager.CurrentProfile;

            if (profile == null) return;

            profile.Reactions.Remove(Reagent1, Reagent2);

            profile.SetPairClipStatus(Reagent1, Reagent2, ClipType.None);

            if (State == TestState.Saved)

            {

                profile.Save();

            }

            Reaction = null;

            BadReaction = null;

            Clipped = ClipType.None;

            State = TestState.Untested;

        }

        public void SaveReaction()

        {

            PlayerProfile? profile = ProfileManager.CurrentProfile;

            if (profile == null) return;

            profile.Reactions.Set(Reagent1, Reagent2, Reaction);

            profile.Save();

            State = TestState.Saved;

        }

        #endregion

        #region Internals

        private Reaction? CalculateReaction()

        {

            if (ProfileManager.CurrentProfile == null) return null;

            if (HypotheticalColor == null) return null;

            if (ObservedColor == null) return null;

            {

                return ReactionScannerService.Calculate3WayReaction(ProfileManager.CurrentProfile, HypotheticalColor,

            }

            return ReactionScannerService.CalculateReaction(HypotheticalColor, ObservedColor);

        }

        private void UpdateHypotheticalColor()

        {

            HypotheticalColor = null;

        }

        #endregion

        #region Interface Implementations

        public event PropertyChangedEventHandler? PropertyChanged;

        [NotifyPropertyChangedInvocator]

        private void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)

        {

            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

        }

        public void Report(float value)

        {

            ScanProgress = (int)Math.Round(value * 100);

        }

        #endregion

        public int CompareTo(ReactionTest? other)

        {

            if (other == null) return 1;

            if (Clipped == ClipType.None)

            {

                if (other.Clipped != ClipType.None) return -1;

            }

            else if (other.Clipped == ClipType.None) return 1;

            if (IsAllCatalysts)

            {

                if (!other.IsAllCatalysts) return 1;

            }

            else if (other.IsAllCatalysts) return -1;

            return string.CompareOrdinal(Reagent1.Name, other.Reagent1.Name) switch

            {

                < 0 => -1,

                > 0 => 1,

                _   => string.CompareOrdinal(Reagent2.Name, other.Reagent2.Name)

            };

        }

    }

}

            int bgErrorCount = 0;

            for (i = 0; result && (i < _swatchWidth - _pixelMultiplier); ++i)

            {

                bool isBorder = pixels.DoesPixelMatch(x + i, y, PixelColor.IsDark);

                result &= isBorder;

                if (!isBorder)

                {

                    WriteLog(LogVerbosity.Normal, "Probable swatch at {0},{1} failed upper border test at {2},{3}", x, y, x + i, y);

                    borderError = true;

                }

                // Checking along the top of the swatch for background

                // The row just above is shaded, so check 2 above

                if (y > 1)

                {

                    bool isUiBackground = pixels.DoesPixelMatch(x + i, y - _swatchTopBorder, PixelColor.IsUiBackground);

                    bgErrorCount += isUiBackground ? 0 : 1;

                }

                else

                {

                    ++bgErrorCount;

                }

                // Checking along the bottom of the swatch for background

                if (y < pixels.Height)

                {

                    bool isUiBackground = pixels.DoesPixelMatch(x + i, y + _swatchHeight, PixelColor.IsUiBackground);

                    bgErrorCount += isUiBackground ? 0 : 1;

                }

                else

                {

                    ++bgErrorCount;

                }

            }

            result &= (bgErrorCount < (_swatchWidth / 20)); // allow up to 5% error rate checking for background texture, because this seems to be inconsistent

            if (!result && ((i > (_swatchWidth * 0.8)) || (bgErrorCount >= (_swatchWidth / 20))))

            {

                if (!borderError && (bgErrorCount < _swatchWidth))

                {

                    WriteLog(LogVerbosity.Normal, "Found a potential swatch candidate of width {0} at {1},{2} that had {3} failures matching background color", i, x, y, bgErrorCount);

                }

            }

            return result;

        }

        private bool TestPosition(int x, int y, Pixels pixels, ref PaintColor reactedColor)

        {

            // Check 4 corners of solid area and left/right solid bar areas

            bool foundSwatch = IsPossibleSwatchUpperLeft(pixels, x, y);

            if (foundSwatch)

            {

                WriteLog(LogVerbosity.Normal, "Found probable swatch at {0},{1} - checking border slices", x, y);

                int borderXOffset = 0;

                for (borderXOffset = _swatchLeftBorder; foundSwatch && (borderXOffset < _swatchTestWidth); ++borderXOffset)

                {

                    foundSwatch &= IsPossibleSwatchSlice(pixels, x + borderXOffset, y);

                    if (!foundSwatch)

                    {

                        WriteLog(LogVerbosity.Normal, "Failed slice test at {0},{1}", x + borderXOffset, y);

                        break;

                    }

                    foundSwatch &= IsPossibleSwatchSlice(pixels, x + _swatchWidth - borderXOffset, y);

                    if (!foundSwatch)

                    {

                        WriteLog(LogVerbosity.Normal, "Failed slice test at {0},{1}", x + _swatchWidth - borderXOffset, y);

                        break;

                    }

                }

            }

            if (!foundSwatch)

            {

                if (!_lockedSwatchWidth)

                {

                    // Reset our guess at swatch width.

                    _swatchWidth = MinSwatchWidth;

                }

                return false;

            }

            // WE FOUND THE SWATCH!

            // Now we know where the color bars are.

            _lockedSwatchWidth = true;

            int redPixelCount = pixels.LengthOfColorAt(x, y + _redBarSpacing, PixelColor.IsRed);

            reactedColor.Red = (byte)Math.Round(redPixelCount * 255f / _swatchWidth);

            int greenPixelCount = pixels.LengthOfColorAt(x, y + _greenBarSpacing, PixelColor.IsGreen);

            reactedColor.Green = (byte)Math.Round(greenPixelCount * 255f / _swatchWidth);

            int bluePixelCount = pixels.LengthOfColorAt(x, y + _blueBarSpacing, PixelColor.IsBlue);

            reactedColor.Blue = (byte)Math.Round(bluePixelCount * 255f / _swatchWidth);

            WriteLog(LogVerbosity.Low, "Found the color swatch at {0}, {1}. Color={2} Red={3}px Green={4}px Blue={5}px", x, y, reactedColor, redPixelCount, greenPixelCount, bluePixelCount);

            return true;

        }

        public async Task<bool> CaptureReactionAsync(IProgress<float> progress)

        {

            _canceler = new CancellationTokenSource(); // You can't re-use these, sadly.

            return await Task.Run(() => CaptureReaction(progress, _canceler.Token));

        }

        private bool CaptureReaction(IProgress<float> progress, CancellationToken cancellToken)

        {

            PaintColor reactedColor = new();

            IsCaptured = false;

            _recordedColor.Clear();

            using (var g = Graphics.FromImage(_targetBitmap))

            {

                Debug.WriteLine("Scan starting at [" + _screenX + ", " + _screenY + "]");

                g.CopyFromScreen(_screenX, _screenY, 0, 0, _targetBitmap.Size, CopyPixelOperation.SourceCopy);

            }

            // _targetBitmap.Save(Path.Combine(ProfileManager.CurrentProfile?.Directory ?? "", "screenshot.png"), ImageFormat.Png);

            Pixels pixels = new(_targetBitmap, _pixelMultiplier);

            IsCaptured = false;

            if (!_firstRun)

            {

                // If this is not the first run, let's check the last location, to see if the UI is still there.

                if (TestPosition(_lastSwatchX, _lastSwatchY, pixels, ref reactedColor))

                {

                    IsCaptured = true;

                    RecordedColor = reactedColor;

                    return true;

                }

                _firstRun = true;

            }

            SettingsService.Get("Log.Verbosity", out var verbosityIdx, 1);

            _logVerbosity = (LogVerbosity)verbosityIdx;

            int patchTestSize = ((_swatchHeight - _swatchTopBorder - _swatchBottomBorder) / 2) - 1;

            SettingsService.Get("ScanArea.Min.X", out var startX, 0);

            SettingsService.Get("ScanArea.Min.Y", out var startY, 0);

            SettingsService.Get("ScanArea.Max.X", out var endX,   _targetBitmap.Width);

            SettingsService.Get("ScanArea.Max.Y", out var endY,   _targetBitmap.Height);

            startX = Math.Max(2, Math.Min(startX, _targetBitmap.Width - 2));

            startY = Math.Max(2, Math.Min(startY, _targetBitmap.Height - 2));

            endX = Math.Min(_targetBitmap.Width  - 2, Math.Max(2, endX)) - _minSwatchWidth; //  + patchTestSize;

            endY = Math.Min(_targetBitmap.Height - 2, Math.Max(2, endY)) - (_blueBarSpacing + 10); // + patchTestSize;

            Debug.WriteLine("startX: " + startX + " endX: " + endX + " startY: " + startY + " endY: " + endY + " with patch test size of " + patchTestSize);

            int xSpan = endX - startX;

            int ySpan = endY - startY;

            int total = xSpan * ySpan;

            for (int roughX = startX; roughX < endX ; roughX += patchTestSize)

            {

                int xMark = roughX - startX;

                for (int roughY = startY; roughY < endY; roughY += patchTestSize)

                {

                    progress.Report((float)((xMark * ySpan) + (roughY - startY)) / total);

                    cancellToken.ThrowIfCancellationRequested();

                    if (!pixels.IsSolidPatchAt(roughX, roughY, patchTestSize, patchTestSize)) continue;

                    Color patchColor = pixels.ColorAt(roughX, roughY);

                    WriteLog(LogVerbosity.Excessive, "Found a solid patch of {2},{3},{4} at {0}, {1}", roughX, roughY, patchColor.R, patchColor.G, patchColor.B);

                    for (int x = Math.Max(0, roughX - patchTestSize - _swatchLeftBorder + _pixelMultiplier); x < roughX; ++x)

                    {

                        for (int y = Math.Max(0, roughY - patchTestSize - _swatchTopBorder + _pixelMultiplier); y < roughY; ++y)

                        {

                            WriteLog(LogVerbosity.Excessive, "Searching for potential swatch at {0},{1} after found square at {2},{3}", x, y, roughX, roughY);

                            if (!TestPosition(x, y, pixels, ref reactedColor)) continue;

                            RecordedColor = reactedColor;

                            _lastSwatchX  = x;

                            _lastSwatchY  = y;

                            _firstRun     = false;

                            IsCaptured    = true;

                            return true;

                        }

                    }

                    WriteLog(LogVerbosity.Excessive, "False-positive patch of color {0},{1},{2} at {3},{4}", patchColor.R, patchColor.G, patchColor.B, roughX, roughY);

                }

            }

            return false;

        }

        {

            // A 3-reagent reaction.

            Debug.Assert(reaction1 != null);

            Debug.Assert(reaction2 != null);

            int r = reactedColor.Red   - expectedColor.Red   - reaction1.Red   - reaction2.Red;

            int g = reactedColor.Green - expectedColor.Green - reaction1.Green - reaction2.Green;

            int b = reactedColor.Blue  - expectedColor.Blue  - reaction1.Blue  - reaction2.Blue;

            return new Reaction(r, g, b);

        }

        public static Reaction CalculateReaction(PaintColor expectedColor, PaintColor reactedColor)

        {

            // A 2-reagent reaction.

            int r = reactedColor.Red   - expectedColor.Red;

            int g = reactedColor.Green - expectedColor.Green;

            int b = reactedColor.Blue  - expectedColor.Blue;

            return new Reaction(r, g, b);

        }

    }

}

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Diagnostics;

using System.Linq;

using System.Reactive;

using System.Reactive.Linq;

using System.Threading.Tasks;

using DesertPaintCodex.Models;

using DesertPaintCodex.Services;

using DesertPaintCodex.Util;

using ReactiveUI;

namespace DesertPaintCodex.ViewModels

{

    public class ReactionTestViewModel : ViewModelBase

    {

        private ReactionTest _reactionTest = Constants.StubReactionTest;

        public ReactionTest ReactionTest

        {

            get => _reactionTest;

            set => this.RaiseAndSetIfChanged(ref _reactionTest, value);

        }

        private readonly List<Reagent> _allPigmentList = new();

        private readonly List<Reagent> _allReagentList = new();

        public ReactionTestViewModel()

        {

            List<string> reagentNames = ReagentService.Names;

            foreach (var reagent in reagentNames.Select(ReagentService.GetReagent))

            {

                if (!reagent.IsCatalyst)

                { 

                    _allPigmentList.Add(reagent);

                }

                _allReagentList.Add(reagent);

            }

            this.WhenAnyValue(x => x.ReactionTest)

                .Subscribe(_ => UpdateDerivedState());

            ShowScreenSettingsDialog = new Interaction<ScreenSettingsViewModel, Unit>();

            SaveReaction = ReactiveCommand.Create(() => ReactionTest.SaveReaction());

            ClearReaction = ReactiveCommand.Create(() => ReactionTest.ClearReaction());

            FinalizeTestResults = ReactiveCommand.Create(Test);

        }

        private void UpdateDerivedState()

        {

            // There are more "reactive" ways to pull this off, but I don't have time to figure out all those recipes

            // right now.

            SetupTest();

        }

        private void SetupTest()

        {

            if (ReactionTest.Requires3Way)

            {

                FilterBufferPigments();

            }

        }

        private void FilterBufferPigments()

        {

            // Avalonia doesn't really have proper filtering for listy controls yet.

            PlayerProfile? profile = ProfileManager.CurrentProfile;

            if (profile == null) return;

            ReactionSet reactions = profile.Reactions;

            List<Reagent> bufferList = ReactionTest.IsAllCatalysts ? _allPigmentList : _allReagentList;

            {

            }

            // BufferPigmentList.AddRange(_allPigmentList.Where(pigment =>

            //         pigment != ReactionTest.Reagent1 && pigment != ReactionTest.Reagent2));

        }

        public async void Analyze()

        {

            Debug.WriteLine("Analyze");

            try

            {

                await ReactionTest.StartScan();

                await FinalizeTestResults.Execute();

            }

            catch (OperationCanceledException)

            {

                Debug.WriteLine("Scan canceled.");

            }

        }

        public void MarkInert()

        {

            ReactionTest.MarkInert();

        }

        public void CancelScan()

        {

            ReactionTest.CancelScan();

        }

        public async Task OpenScreenSettings()

        {

            await ShowScreenSettingsDialog.Handle(new ScreenSettingsViewModel());

        }

        public async Task ShowClipInfo()

        {

            await ShowInfoBox("Clipped Reactions", "The Pigment Lab is only capable of displaying color channel values in the 0-255 range. However, sometimes, your reactions will push one or more channels outside of that range. When that happens, the value will be clamped either to 0 or 255. In this case, we say that the reaction was \"Clipped.\"\n\nThis is nothing to panic about, though. We solve this issue by using a third (buffer) reagent to offset the extreme value, so that it falls within measurable range, similar to how we test Catalyst+Catalyst reactions. Desert Paint Codex will automatically do the math for this, but it does move clipped reactions towards the end of your test list, because you'll want any reactions between the buffer reagent and your two test reagents already known, prior to running your buffered test.");

        }

        private void Test()

        {

            Debug.WriteLine("Test complete");

        }

        public Interaction<ScreenSettingsViewModel, Unit> ShowScreenSettingsDialog { get; }

        public ReactiveCommand<Unit, Unit> ClearReaction { get; }

        public ReactiveCommand<Unit, Unit> SaveReaction { get; }

        public ReactiveCommand<Unit, Unit> FinalizeTestResults { get; }

    }

}

<UserControl xmlns="https://github.com/avaloniaui"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

             xmlns:views="clr-namespace:DesertPaintCodex.Views"

             xmlns:vm="clr-namespace:DesertPaintCodex.ViewModels"

             mc:Ignorable="d" d:DesignWidth="310" d:DesignHeight="450"

             x:Class="DesertPaintCodex.Views.ReactionTestView"

             IsVisible="{Binding Path=!ReactionTest.IsStub}"

             >

    <Design.DataContext>

        <vm:ReactionTestViewModel />

    </Design.DataContext>

    <UserControl.Styles>

        <Style Selector="StackPanel.ReagentRow">

            <Setter Property="Orientation" Value="Horizontal"/>

            <Setter Property="Spacing" Value="10"/>

            <Setter Property="Height" Value="30"/>

        </Style>

        <Style Selector="TextBlock.ReagentLabel">

            <Setter Property="VerticalAlignment" Value="Center"/>

            <Setter Property="TextAlignment" Value="Right"/>

            <Setter Property="Width" Value="80"/>

        </Style>

        <Style Selector="TextBlock.ReagentName">

            <Setter Property="VerticalAlignment" Value="Center"/>

            <Setter Property="Width" Value="120"/>

        </Style>

    </UserControl.Styles>

    <StackPanel Spacing="20" Margin="20 0 0 0">

        <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="5">

            <TextBlock Classes="BlockHeader">REAGENTS</TextBlock>

            <Border Classes="ThinFrame">

                <StackPanel Orientation="Vertical" Spacing="10">

                                  IsVisible="{Binding ReactionTest.CanPickBuffer}"