private static readonly Regex _recipeHeaderRegex     = new(@"^--- Recipe: (?<colorname>(\w*\s)*\w+)\s*");

        private static readonly Regex _recipeIngredientRegex = new(@"(?<ingredient>(\w+\s)?\w+)\s*\|\s*(?<quantity>\d+)\s*");

        private Settings ProfileSettings { get; } = new();

        public string Directory { get; }

        public string Name { get; private set; }

        public ReactionSet Reactions { get; } = new();

        public string ReagentFile { get; }

        public Dictionary<string, PaintRecipe> Recipes { get; } = new();

        public Dictionary<string, PaintRecipe> RibbonRecipes { get; } = new();

        public int RecipeCount

        {

            get

            {

                int count = 0;

                        Reaction reaction = new(

                            int.Parse(tokens[2].Trim()),

                            int.Parse(tokens[3].Trim()),

                            int.Parse(tokens[4].Trim())

                            );

                        Reactions.Set(reagent1, reagent2, reaction);

                    }

                }

            }

            if (!File.Exists(_clipFile)) return true;

            {

                while ((line = reader.ReadLine()) != null)

                {

                    string[] tokens = line.Split(' ');

                    if (tokens.Length != 3) continue;

                    string reagent1 = tokens[0].Trim();

                    if (!Clippers.ContainsKey(reagent1))

                    {

                        Clippers.Add(reagent1, new Dictionary<string, ClipType>());

                    }

                    Clippers[reagent1][tokens[1].Trim()] = (ClipType)int.Parse(tokens[2].Trim());

                        }

                        Reagent reagent1 = ReagentService.GetReagent(reagentName1);

                        Reagent reagent2 = ReagentService.GetReagent(reagentName2);

                        reaction = Reactions.Find(reagent1, reagent2);

                        if (reaction != null)

                        {

                            writer.WriteLine(reagent1.PracticalPaintName + " " + reagent2.PracticalPaintName + " " +

                            reaction.Red + " " + reaction.Green + " " + reaction.Blue);

                        }

                    }

                }

            }

            {

                foreach (var item1 in Clippers)

                {

                    foreach (var item2 in item1.Value)

                    {

                        writer.WriteLine(item1.Key + " " + item2.Key + " " + (int)item2.Value);

                    }

                }

            }

        }

        {

            {

                {

                    return clipType;

                }

            }

            return ClipType.None;

        }

        private void LoadRecipes(Dictionary<string, PaintRecipe> recipeDict, string filename, uint concentration)

        {

            foreach (PaintRecipe recipe in recipeDict.Values)

            {

                recipe.Clear();

            }

            string      recipeFile         = Path.Combine(Directory, filename);

            bool        inRecipe           = false;

            PaintRecipe testRecipe         = new();

            string?     currentRecipeColor = null;

            if (!File.Exists(recipeFile)) return;

                if (_bufferReagent == null)

                {

                    _recipe.AddReagent(Reagent1.Name);

                    _recipe.AddReagent(Reagent2.Name);

                }

                else

                {

                    _recipe.AddReagent(_bufferReagent.Name);

                    _recipe.AddReagent(Reagent1.Name);

                    _recipe.AddReagent(Reagent2.Name);

                }

                NotifyPropertyChanged(nameof(BufferReagent));

                NotifyPropertyChanged(nameof(CanScan));

            }

        }

        private ClipType _clipType;

        public ClipType Clipped {

            get => _clipType;

            set

            {

                _clipType = value;

                NotifyPropertyChanged(nameof(Clipped));

            }

        }

            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));

            }

        }

        public bool Requires3Way =>

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

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

        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;

        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;

        }

        #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);

                        }

                        | _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();

                    }

                }

            }

            else

            {

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

                State = TestState.LabNotFound;

            }

        }

        public void CancelScan()

        {

            ReactionScannerService.Instance.CancelScan();

        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);

            if (State == TestState.Saved)

            {

                profile.Save();

            }

            Reaction = null;

            BadReaction = null;

            State = TestState.Untested;

        }

        public void SaveReaction()

        {

        }

        #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,

                    ObservedColor, BufferReagent, Reagent1, Reagent2);

            }

            return ReactionScannerService.CalculateReaction(HypotheticalColor, ObservedColor);

        }

        #endregion

        #region Interface Implementations

        public event PropertyChangedEventHandler? PropertyChanged;

        [NotifyPropertyChangedInvocator]

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

        {

            Debug.Assert(profile != null);

            List<string> reagentNames = ReagentService.Names;

            foreach (Reagent reagent1 in reagentNames.Select(ReagentService.GetReagent))

            {

                foreach (Reagent reagent2 in reagentNames.Select(ReagentService.GetReagent))

                {

                    if (reagent1 == reagent2) continue;

                    Reaction? reaction = profile.FindReaction(reagent1, reagent2);

                    ReactionTest test = new(reagent1, reagent2, reaction, clipType)

                    {

                        Clipped  = clipType,

                        Reaction = reaction,

                    };

                    _allTests.Add(test);

                }

            }

        }

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();

        public ReactionTestViewModel()

        {

            List<string> reagentNames = ReagentService.Names;

            {

            }

            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()

        private void SetupTest()

        {

            if (ReactionTest.Requires3Way)

            {

                FilterBufferPigments();

            }

        }

        private void FilterBufferPigments()

        {

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

        }

        public async void Analyze()

        {

            Debug.WriteLine("Analyze");

            try

            {

                await ReactionTest.StartScan();

                await FinalizeTestResults.Execute();

            }

            catch (OperationCanceledException)

            {

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

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

        xmlns:vm="using:DesertPaintCodex.ViewModels"

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

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

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

        mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="800"

        Width="640" Height="800"

        MinWidth="600" MinHeight="500"

        x:Class="DesertPaintCodex.Views.MainWindow"

        Icon="/Assets/desert_paint_codex_icon.ico"

        Title="Desert Paint Codex">

    <Design.DataContext>

        <vm:MainWindowViewModel/>

    </Design.DataContext>

    <Window.DataContext>

        <vm:MainWindowViewModel/>

    </Window.DataContext>

            <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">

                    <StackPanel Classes="ReagentRow" IsVisible="{Binding ReactionTest.Requires3Way}">

                        <TextBlock Classes="ReagentLabel">Buffer:</TextBlock>

                                  SelectedItem="{Binding ReactionTest.BufferReagent}"

                                  PlaceholderText="Choose" Width="120" Height="30">

                            <ComboBox.ItemTemplate>

                                <DataTemplate>

                                    <TextBlock Text="{Binding Name}" />

                                </DataTemplate>

                            </ComboBox.ItemTemplate>

                        </ComboBox>

                        <Border Classes="ReagentSwatch"

                            Background="{Binding ReactionTest.BufferReagent.Color, Converter={StaticResource paintToBrush}, FallbackValue=#00000000}" />

                    </StackPanel>

                    <StackPanel Classes="ReagentRow">