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

                    {

                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)

                {

            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)

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;

            {

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

        }

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

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

    <Window.Styles>

        <!--

        <Style Selector="Menu">

            <Setter Property="Background" Value="#282828"/>

        </Style>

        -->

        <Style Selector="ContentControl">

            <Setter Property="Margin" Value="0 5 0 0"/>

        </Style>

        <Style Selector="TextBlock.StatusBar">

            <Setter Property="Margin" Value="5"/>

        </Style>

        <Style Selector="TabControl.ActivityPicker WrapPanel">

            <Setter Property="Background" Value="{DynamicResource GutterBackgroundBrush}"/>

        </Style>

        <Style Selector="TabControl.ActivityPicker">

            <Setter Property="Background" Value="{DynamicResource FlatBackgroundBrush}"/>

        </Style>

             >

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

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

                        <TextBlock Classes="ReagentLabel">Reagent #1:</TextBlock>

                        <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.Reagent1.Name}" />

                        <Border Classes="ReagentSwatch"

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

                    </StackPanel>

                    <StackPanel Classes="ReagentRow">

                        <TextBlock Classes="ReagentLabel">Reagent #2:</TextBlock>

                        <TextBlock Classes="ReagentName" Text="{Binding ReactionTest.Reagent2.Name}" />

                        <Border Classes="ReagentSwatch"

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

                    </StackPanel>

                </StackPanel>

            </Border>

        </StackPanel>

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

            <TextBlock Classes="BlockHeader">HYPOTHETICAL COLOR</TextBlock>

            <views:PaintSwatchView ShowName="False" Color="{Binding ReactionTest.HypotheticalColor}"/>

        </StackPanel>