I want each miner have its own Produce Resources routine independently

using System;
using System.Collections;
using System.Collections.Generic;
using Game.ImprovedAI;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Serialization;

namespace Game.Systems.Buildings
{
    public class StoneMine : BuildingBase
    {

        [Header("Building Stats")]
        [SerializeField] private GameObject minerPrefab;
        [SerializeField] private float productionTime = 5f;
        [SerializeField] private float resourcesProduced = 1;
        [SerializeField] private List<GameObject> rocks = new List<GameObject>();
        [SerializeField] private GameObject loadingPoint;
        [SerializeField] private GameObject spawnPoint;
        [SerializeField] private GameObject workingPoint;

        
        private List<Miner> miners = new List<Miner>();
        private List<Miner> disabledMiners = new List<Miner>();

        
        [SerializeField] bool isDay;
        
        public float totalResourcesProduced;
        public bool id;
        
        private int activeVillagers;
        
        
        public override void Init()
        { 
           base.Init();
           totalResourcesProduced = 0;

           StartCoroutine(ProduceResources());
           isDay = true;
           
           
           GameManager.Instance.OnDayStart += DayAction;
           GameManager.Instance.OnNightStart += NightAction;
           
           GameManager.Instance.BuilderManager.AddBuildingToQueue(this);
        }

        private void Update()
        {
            if (showingPanel)
            {
                buildingPanelManager.UpdateHealth(buildingHealth.health, buildingHealth.maxHealth);
            }
        }

        public override void BuildingAction()
        {
            
        }

        public override void AssignedVillager()
        {
            Miner miner;
            if (disabledMiners.Count == 0)
            {
                GameObject minerGO = Instantiate(minerPrefab, transform.position, quaternion.identity);
                miner = minerGO.GetComponent<Miner>();
                if (miner != null)
                {
                    miner.Init(this);
                    miners.Add(miner);
                }
            }
            else
            {
                miner = disabledMiners[0];
                miner.gameObject.SetActive(true);
                miner.Init(this);
                disabledMiners.RemoveAt(0);
                miners.Add(miner);
            }
        }

        public override void RemoveVillager()
        {
            if (assignedVillagers > 0)
            {
                assignedVillagers--;
                Miner miner = miners[0];
                miner.gameObject.SetActive(false);
                disabledMiners.Add(miner);
                miners.RemoveAt(0);
                miner.DisableVillager();
            }
        }

        public override void DemolishedAction()
        {
            if (assignedVillagers > 0)
            {
                GameManager.Instance.VillagersPlacer.AddVillagers(assignedVillagers);
                foreach (var forester in miners)
                {
                    forester.DisableVillager();
                    Destroy(forester.gameObject);
                }
            }
            buildingHealth.TakeDamage(float.MaxValue, true);
        }

        public override void InitPanel()
        {
            showingPanel = true;
            buildingPanelManager.Init(BuildingPanelManager.BuildingPanelType.B, name, description, this);
        }

        // Each farmer gets their own method to produce food
        private IEnumerator ProduceResources()
        {
            float timer = 0;
            
            while (true)
            {
                if (assignedVillagers > 0)
                {
                    if (timer == 0)
                    {
                        activeVillagers = assignedVillagers;
                        foreach (var miner in miners)
                        {
                            //miner.Move(workingPoint);
                        }
                    }
    
                    if (timer < productionTime)
                    {
                        if (isDay)
                        {
                            timer += Time.deltaTime * assignedVillagers;
                        }
                    }
                    else
                    {
                        
                        foreach (var miner in miners)
                        {
                            //miner.MoveTo(loadingPoint.transform.position);
                        }
                        totalResourcesProduced += resourcesProduced;
                        GameManager.Instance.StatsManager.PendingStone += resourcesProduced;
                        timer = 0;
                    }
                }
                else
                {
                    timer = 0;
                }

                if (buildingPanelManager != null)
                {
                    buildingPanelManager.UpdateProduction(BuildingPanelManager.ProductionType.Wood, isDay,
                        resourcesProduced * assignedVillagers, totalResourcesProduced,
                        timer / productionTime, productionTime - timer, assignedVillagers);
                    buildingPanelManager.UpdateWorkers(assignedVillagers, maxVillagers);
                }

                yield return null;
            }
        }
        
       
        public void DayAction(object sender, EventArgs args)
        {
            isDay = true;
            totalResourcesProduced = 0;
        }
        
        public void NightAction(object sender, EventArgs args)
        {
            isDay = false;
        }
        
        public override void DestroyedAction()
        {
            if (showingPanel)
            {
                GameManager.Instance.BuildingPanelManager.DisableAllPanels();
            }
            StopAllCoroutines();
            
            foreach (var miner in miners)
            {
                miner.gameObject.SetActive(false);
                disabledMiners.Add(miner);
                miners.Remove(miner);
                miner.DisableVillager();
            }
        }
        
        void OnDestroy()
        {
            // Stop all coroutines when the farm object is destroyed
            StopAllCoroutines();
            GameManager.Instance.OnDayStart -= DayAction;
            GameManager.Instance.OnNightStart -= NightAction;
        }
    }
}