using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BaseCellSimulation.Enzyms.Cytosol.Ribosomen
{
    public class Ribosome : InternalEnzym
    {
        private TranslationFactor initiation;
        private TranslationFactor elongation;
        private TranslationFactor termination;

        private const double ProteinPermRNA = 20.0;

        int ribosomenState = 0;

        public Ribosome()
        {
            Km = 0.5;    // fiktiv (abhängig von mRNA)
            Vmax = 10.0; // z. B. 10 Aminosäuren pro Sekunde
            initiation = new TranslationFactor(TranslationFactor.FactorType.Initiation);
            elongation = new TranslationFactor(TranslationFactor.FactorType.Elongation);
            termination = new TranslationFactor(TranslationFactor.FactorType.Termination);
        }

        private double availableAA = 0;
        private double dProtein = 0;

        public override void ApplyChanges(CellRessources res, double dt)
        {
            int safety = 0;
            while (safety++ < 10)
            {
                switch (ribosomenState)
                {

                    case 0:
                        availableAA = res.Res.Protein.AminoAcids;
                        dProtein = rate * dt;
                        // Translation start -> Initiationsfaktoren verbrauchen GTP
                        initiation.ApplyChanges(res, dt * 0.5);
                        if (initiation.TranslationSpeed > 0)
                        {
                            dProtein = Math.Min(initiation.TranslationSpeed, dProtein);
                            dProtein = Math.Min(dProtein, Math.Min(res.Res.Protein.mRNA, availableAA));
                            res.Res.Protein.AminoAcids -= dProtein;
                            res.Res.Protein.FunctionalProteins += dProtein;
                            ribosomenState = 1;
                        }
                        else return;
                        break;
                    case 1:
                        elongation.ApplyChanges(res, dt * dProtein * 0.1);
                        if (elongation.TranslationSpeed > 0)
                        {
                            dProtein = Math.Min(elongation.TranslationSpeed, dProtein);
                            // mRNA-Abnutzung: jede mRNA kann nur begrenzt oft benutzt werden
                            double used_mRNA = dProtein / ProteinPermRNA;
                            res.Res.Protein.mRNA -= used_mRNA;

                            // Abbauprodukte: ein Teil recycelt, ein Teil wird zu Waste
                            double degraded = used_mRNA * 0.8;
                            double lost = used_mRNA * 0.2;
                            res.Res.Protein.Nucleotides += degraded;  // Rückgewinn von Basen
                            res.Res.Protein.Waste += lost;            // Restliche RNA-Fragmente als Zellabfall
                            ribosomenState = 2;
                        }

                        else return;
                        break;

                    case 2:
                        termination.ApplyChanges(res, dt * 0.01 * dProtein);
                        if (termination.TranslationSpeed > 0)
                        {
                            res.ConsumeATP(dProtein * 4); // z. B. 4 ATP pro Peptidbindung  -> ADP 
                            ribosomenState = 0;
                        }
                        else return; 

                        break;
                            
                }
            }
        }

        public override void ComputeRate(Resources res)
        {
            if (ribosomenState == 0) { 
                if (res.Protein.AminoAcids <= 0.0 || res.Protein.mRNA <= 0.0)
                    return;

                double availablemRNA = res.Protein.mRNA;
                Michaelis_Menten(availablemRNA);
                initiation.ComputeRate(res);
                elongation.ComputeRate(res);
                termination.ComputeRate(res);
            }
        }
    }
}