using System;

using System.Collections.Generic;

using System.IO;

using System.Text.RegularExpressions;

namespace DesertPaintCodex.Models

{

    public class RecipeSearchNode

    {

        private readonly uint[] _reagents;

        private readonly uint _invalidReagent;

        private int _nextReagentPos;

        public int ReagentCount => _nextReagentPos;

        private readonly bool[] _reagentInUse;

        private readonly List<Reagent> _costSortedReagents;

        public PaintRecipe? TestRecipe { get; set; }

        public uint CurrentTargetQuantity { get; set; }

        public uint MaxConcentration { get; set; }

        public uint UsedQuantity { get; private set; }

        public uint CatalystCount { get; set; }

        public uint FullQuantityDepth { get; set; }

        public uint FullQuantity { get; set; }

        public uint MinReagents { get; set; }

        public bool ShouldLog { get; private set; }

        public Action<string>? WriteLog = null;

        private uint _maxReagents;

        public uint MaxReagents

        {

            get => _maxReagents;

            set

            {

                _maxReagents = value;

                CurrentWeights = new uint[_maxReagents];

            }

        }

        public uint[] CurrentWeights { get; private set; }

        public uint LastReagent => _reagents[_nextReagentPos - 1];

        public RecipeSearchNode(RecipeSearchNode other)

        {

            _costSortedReagents = new List<Reagent>(other._costSortedReagents);

            _reagents = new uint[_costSortedReagents.Count];

            _invalidReagent = (uint)_costSortedReagents.Count;

            for (int i = 0; i < _costSortedReagents.Count; ++i)

            {

                this._reagents[i] = other._reagents[i];

            }

            _reagentInUse = new bool[_costSortedReagents.Count];

            for (uint i = 0; i < _costSortedReagents.Count; ++i)

            {

                _reagentInUse[i] = other._reagentInUse[i];

            }

            _nextReagentPos = other.ReagentCount;

            CurrentTargetQuantity = other.CurrentTargetQuantity;

            MaxConcentration = other.MaxConcentration;

            UsedQuantity = other.UsedQuantity;

            CatalystCount = other.CatalystCount;

            FullQuantityDepth = other.FullQuantityDepth;

            FullQuantity = other.FullQuantity;

            MinReagents = other.MinReagents;

            MaxReagents = other.MaxReagents;

            CurrentWeights = new uint[MaxReagents];

            for (int i = 0; i < MaxReagents; ++i)

            {

                CurrentWeights[i] = other.CurrentWeights[i];

            }

            RefreshShouldLog();

        }

        public RecipeSearchNode(List<Reagent> costSortedReagents, uint[] reagents)

        {

            _costSortedReagents = new List<Reagent>(costSortedReagents);

            _reagents = new uint[costSortedReagents.Count];

            _invalidReagent = (uint)costSortedReagents.Count;

            _nextReagentPos = reagents.Length;

            for (int i = _reagents.Length - 1; i >= _reagents.Length; --i)

            {

                reagents[i] = _invalidReagent;

            }

            for (int i = reagents.Length - 1; i >= 0; --i)

            {

                _reagents[i] = reagents[i];

                if (reagents[i] == _invalidReagent)

                {

                    _nextReagentPos = i;

                }

            }

            _reagentInUse = new bool[costSortedReagents.Count];

            for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)

            {

                _reagentInUse[reagentIdx] = false;

            }

            foreach (uint reagentIdx in this._reagents)

            {

                if (reagentIdx != _invalidReagent)

                {

                    _reagentInUse[reagentIdx] = true;

                }

            }

            MinReagents = (uint) _nextReagentPos;

            MaxReagents = (uint) _nextReagentPos;

            CurrentWeights = new uint[MaxReagents];

            UsedQuantity = 0;

            RefreshShouldLog();

        }

        // top-level search

        public RecipeSearchNode(List<Reagent> costSortedReagents, uint startReagent)

        {

            _costSortedReagents = new List<Reagent>(costSortedReagents);

            _reagents = new uint[costSortedReagents.Count];

            _invalidReagent = (uint)costSortedReagents.Count;

            _nextReagentPos = 0;

            for (int i = 0; i < _reagents.Length; ++i)

            {

                _reagents[i] = _invalidReagent;

            }

            _reagentInUse = new bool[costSortedReagents.Count];

            for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)

            {

                _reagentInUse[reagentIdx] = false;