using System;

using System.IO;

using System.IO.Compression;

using System.Collections.Generic;

using System.Text.RegularExpressions;

using DesertPaintCodex.Util;

using DesertPaintCodex.Services;

namespace DesertPaintCodex.Models

{

    public class PlayerProfile

    {

        private const string PaintRecipeFile = "dp_recipes.txt";

        private const string RibbonRecipeFile = "dp_ribbons.txt";

        private readonly string _reactFile;

        private readonly string _settingsFile;

        private readonly string _clipFile;

        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;

                foreach (PaintRecipe recipe in Recipes.Values)

                {

                    if (recipe.IsValidForConcentration(PaintRecipe.PaintRecipeMinConcentration))

                    {

                        ++count;

                    }

                }

                return count;

            }

        }

        public int RibbonCount

        {

            get

            {

                int count = 0;

                foreach (PaintRecipe recipe in RibbonRecipes.Values)

                {

                    if (recipe.IsValidForConcentration(PaintRecipe.RibbonRecipeMinConcentration))

                    {

                        ++count;

                    }

                }

                return count;

            }

        }

        public PlayerProfile(string name, string directory)

        {

            Name          = name;

            Directory     = directory;

            _reactFile    = Path.Combine(directory, "dp_reactions.txt");

            ReagentFile   = Path.Combine(directory, "ingredients.txt");

            _settingsFile = Path.Combine(directory, "settings");

            _clipFile     = Path.Combine(directory, "clips.txt");

            foreach (PaintColor color in PaletteService.Colors)

            {

                Recipes.Add(color.Name, new PaintRecipe());

            }

            foreach (PaintColor color in PaletteService.Colors)

            {

                RibbonRecipes.Add(color.Name, new PaintRecipe());

            }

        }

        public bool Initialize()

        {

            // Copy template files into new directory.

            string? templatePath = FileUtils.FindApplicationResourceDirectory("template");

            if (templatePath == null)

            {

            try

            {

                // If there is an ingredients file, move it in.

                File.Copy(

                    Path.Combine(importDir, "ingredients.txt"),

                    Path.Combine(Directory, "ingredients.txt"),

                    true);

            }

            catch (Exception)

            {

                // If there is no ingredients file, we don't really care.	

            }

        }

        public void Import(string file)

        {

            ZipFile.ExtractToDirectory(file, Directory);

        }

        public void Export(string file)

        {

            ZipFile.CreateFromDirectory(Directory, file);

        }

        public bool Load()

        {

            string? line;

            ProfileSettings.Reset();

            ProfileSettings.Load(_settingsFile);

            Reactions.Clear();

            if (File.Exists(ReagentFile))

            {

                ReagentService.LoadProfileReagents(ReagentFile);

            }

            else

            {

                return false;

            }

            ReagentService.InitializeReactions(Reactions);

            if (!File.Exists(_reactFile))

            {

                return false;

            }

            using (StreamReader reader = new(_reactFile))

            {

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

                {

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

                    if (tokens.Length == 5)

                    {

                        Reagent reagent1 = ReagentService.GetReagent(tokens[0].Trim());

                        Reagent reagent2 = ReagentService.GetReagent(tokens[1].Trim());

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

                }

            }

            return true;

        }

        public void Save()

        {

            ProfileSettings.Save(_settingsFile);

            Reaction? reaction;

            using (StreamWriter writer = new(_reactFile, false))

            {

                foreach (string reagentName1 in ReagentService.Names)

                {

                    // TODO: could be more efficient by only iterating over the names after reagent1

                    foreach (string reagentName2 in ReagentService.Names)

                    {

                        if (reagentName1.Equals(reagentName2))

                        {

                            continue;

                        }

                        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;

            using StreamReader reader = new(recipeFile);

            string? line;

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

            {

                Match match = _recipeHeaderRegex.Match(line);

                if (match.Success)

                {

                    // Store previous recipe.

                    if ((currentRecipeColor != null) && testRecipe.IsValidForConcentration(concentration))

                    {

                        SetRecipe(currentRecipeColor, testRecipe);

                    }

                    testRecipe.Clear();

                    currentRecipeColor = match.Groups["colorname"].Value;

                    inRecipe  = true;

                }

                else if (inRecipe)

                {

                    match = _recipeIngredientRegex.Match(line);

                    if (!match.Success) continue;

                    string ingredient = match.Groups["ingredient"].Value;

                    uint   quantity   = uint.Parse(match.Groups["quantity"].Value);

                    testRecipe.AddReagent(ingredient, quantity);

                }

            }

            if (!inRecipe || (currentRecipeColor == null)) return;

            // Store final recipe.

            if (testRecipe.IsValidForConcentration(concentration))

            {

                SetRecipe(currentRecipeColor, testRecipe);

            }

        }

        private void SaveRecipes(Dictionary<string, PaintRecipe> recipeDict, string filename)

        {

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

            using StreamWriter writer = new(recipeFile, false);

            foreach (KeyValuePair<string, PaintRecipe> pair in recipeDict)

            {

                writer.WriteLine("--- Recipe: {0}", pair.Key);

                foreach (PaintRecipe.ReagentQuantity ingredient in pair.Value.Reagents)

                {

                    writer.WriteLine("{0,-14} | {1}", ingredient.Name, ingredient.Quantity);

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

        private Reagent? _bufferReagent;

        public Reagent? BufferReagent

        {

            get => _bufferReagent;

            set

            {

                if (_bufferReagent == value) return;

                _bufferReagent = value;

                _recipe.Clear();

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

            }

        }

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

            }

        }

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

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

                    }

                }

            }

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

            if (State == TestState.Saved)

            {

                profile.Save();

            }

            Reaction = null;

            BadReaction = null;

            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,

                    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)

        {

            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)

            };

        }

    }

}

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Diagnostics;

using System.Linq;

using DesertPaintCodex.Services;

using DynamicData;

namespace DesertPaintCodex.Models

{

    public static class ReactionTestService

    {

        private static readonly List<ReactionTest> _allTests = new();

        static ReactionTestService()

        {

        }

        public static void Initialize()

        {

            _allTests.Clear();

            PlayerProfile? profile = ProfileManager.CurrentProfile;

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

                }

            }

        }

        public static void PopulateRemainingTests(ObservableCollection<ReactionTest> collection)

        {

            collection.Clear();

            collection.AddRange(_allTests.Where(test => test.State != ReactionTest.TestState.Saved).OrderBy(test => test));

        }

        public static void PopulateCompletedTests(ObservableCollection<ReactionTest> collection)

        {

            collection.Clear();

            collection.AddRange(_allTests.Where(test => test.State == ReactionTest.TestState.Saved).OrderBy(test => 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()

        {

            // 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.

        }

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

    }

}

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