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, IComparable { public enum TestState { Unset = -1, Untested, Scanning, LabNotFound, ClippedResult, GoodResult, Saved } public Reagent Reagent1 { get; } public Reagent Reagent2 { get; } private Reagent? _bufferReagentFirst; public Reagent? BufferReagentFirst { get => _bufferReagentFirst; set { if (_bufferReagentFirst == value) return; _bufferReagentFirst = value; UpdateRecipe(); NotifyPropertyChanged(nameof(BufferReagentFirst)); NotifyPropertyChanged(nameof(CanScan)); } } private Reagent? _bufferReagentLast; public Reagent? BufferReagentLast { get => _bufferReagentLast; set { if (_bufferReagentLast == value) return; _bufferReagentLast = value; UpdateRecipe(); NotifyPropertyChanged(nameof(BufferReagentLast)); NotifyPropertyChanged(nameof(CanScan)); } } private bool _useFirstBuffer; public bool UseFirstBuffer { get => _useFirstBuffer; set { _useFirstBuffer = value; UpdateRecipe(); NotifyPropertyChanged(nameof(UseFirstBuffer)); NotifyPropertyChanged(nameof(CanScan)); NotifyPropertyChanged(nameof(ShowFirstBuffer)); NotifyPropertyChanged(nameof(ShowLastBuffer)); } } 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)); NotifyPropertyChanged(nameof(ShowFirstBuffer)); NotifyPropertyChanged(nameof(ShowLastBuffer)); } } public bool Requires3Way => (State == TestState.ClippedResult) || IsAllCatalysts; public bool CanScan => (State is TestState.Untested or TestState.LabNotFound) || ((State == TestState.ClippedResult) && BufferIsSelected); 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; public bool ShowFirstBuffer => Requires3Way && UseFirstBuffer; public bool ShowLastBuffer => Requires3Way && !UseFirstBuffer; 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; UseFirstBuffer = true; 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 testing3Way = Requires3Way && BufferIsSelected; 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(); // SPECIAL CASE: // Check to see if we've got a white-shift reaction that's partially clipped, where we can // still extrapolate the reaction, based on the available information. if (!testing3Way && (BadReaction != null)) { PaintColor baseColor = _recipe.BaseColor; if ((BadReaction.Red < baseColor.Red) && (BadReaction.Green < baseColor.Green) && (BadReaction.Blue < baseColor.Blue)) { // White-shift down clip. bool extrapolated = ExtrapolateWhiteFromOneChannel(_observedColor.Red, 0, BadReaction.Red); if (!extrapolated) extrapolated = ExtrapolateWhiteFromOneChannel(_observedColor.Green, 0, BadReaction.Green); if (!extrapolated) ExtrapolateWhiteFromOneChannel(_observedColor.Blue, 0, BadReaction.Blue); } else if ((BadReaction.Red > baseColor.Red) && (BadReaction.Green > baseColor.Green) && (BadReaction.Blue > baseColor.Blue)) { // White-shift up clip. bool extrapolated = ExtrapolateWhiteFromOneChannel(_observedColor.Red, 255, BadReaction.Red); if (!extrapolated) extrapolated = ExtrapolateWhiteFromOneChannel(_observedColor.Green, 255, BadReaction.Green); if (!extrapolated) ExtrapolateWhiteFromOneChannel(_observedColor.Blue, 255, BadReaction.Blue); } } } PlayerProfile? profile = ProfileManager.CurrentProfile; profile?.SetPairClipStatus(Reagent1, Reagent2, Clipped); } } else { Debug.WriteLine("ERROR: Lab UI not found."); State = TestState.LabNotFound; } } private bool ExtrapolateWhiteFromOneChannel(int result, int clipBound, int reaction) { if (result == clipBound) return false; Clipped = ClipType.None; Reaction = new Reaction(reaction, reaction, reaction); BadReaction = null; State = TestState.GoodResult; return true; } 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; if (_useFirstBuffer) { if (BufferReagentFirst != null) { return ReactionScannerService.Calculate3WayReaction(ProfileManager.CurrentProfile, HypotheticalColor, ObservedColor, BufferReagentFirst, Reagent1, Reagent2, true); } } else { if (BufferReagentLast != null) { return ReactionScannerService.Calculate3WayReaction(ProfileManager.CurrentProfile, HypotheticalColor, ObservedColor, Reagent1, Reagent2, BufferReagentLast, false); } } return ReactionScannerService.CalculateReaction(HypotheticalColor, ObservedColor); } private void UpdateHypotheticalColor() { HypotheticalColor = null; HypotheticalColor = (IsAllCatalysts && !BufferIsSelected) ? null : _recipe.BaseColor; } private bool BufferIsSelected => UseFirstBuffer ? (BufferReagentFirst != null) : (BufferReagentLast != null); private void UpdateRecipe() { _recipe.Clear(); if (_useFirstBuffer) { if (_bufferReagentFirst == null) { _recipe.AddReagent(Reagent1.Name); _recipe.AddReagent(Reagent2.Name); } else { _recipe.AddReagent(_bufferReagentFirst.Name); _recipe.AddReagent(Reagent1.Name); _recipe.AddReagent(Reagent2.Name); } } else { if (_bufferReagentLast == null) { _recipe.AddReagent(Reagent1.Name); _recipe.AddReagent(Reagent2.Name); } else { _recipe.AddReagent(Reagent1.Name); _recipe.AddReagent(Reagent2.Name); _recipe.AddReagent(_bufferReagentLast.Name); } } UpdateHypotheticalColor(); } #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) }; } } }