using RimWorld;
using RimWorld.Planet;
using rjw;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;
using Verse;

namespace RJW_Menstruation
{
    [Flags]
    public enum SeasonalBreed
    {
        Always = 0,
        Spring = 1,
        Summer = 2,
        Fall = 4,
        Winter = 8,
        FirstHalf = Spring | Summer,
        SecondHalf = Fall | Winter
    }


    public class CompProperties_Menstruation : HediffCompProperties
    {
        public float maxCumCapacity; // ml
        public float baseImplantationChanceFactor;
        public float basefertilizationChanceFactor;
        public int follicularIntervalDays = 14; //before ovulation including beginning of bleeding
        public int lutealIntervalDays = 14; //after ovulation until bleeding
        public int bleedingIntervalDays = 6; //must be less than folicularIntervalDays
        public int recoveryIntervalDays = 10; //additional infertile days after gave birth
        public int eggLifespanDays = 2; //fertiledays = ovaluationday - spermlifespan ~ ovaluationday + egglifespanday
        public string wombTex = "Womb/Womb"; //fertiledays = ovaluationday - spermlifespan ~ ovaluationday + egglifespanday
        public string vagTex = "Genitals/Vagina"; //fertiledays = ovaluationday - spermlifespan ~ ovaluationday + egglifespanday
        public bool infertile = false;
        public bool concealedEstrus = false;
        public SeasonalBreed breedingSeason = SeasonalBreed.Always;
        public int estrusDaysBeforeOvulation = 3;
        public int eggMultiplier = 1;


        public CompProperties_Menstruation()
        {

            compClass = typeof(HediffComp_Menstruation);
        }
    }


    public class CompProperties_Anus : HediffCompProperties
    {
        public string analTex = "Genitals/Anal";

        public CompProperties_Anus()
        {
            compClass = typeof(HediffComp_Anus);
        }
    }

    public class HediffComp_Menstruation : HediffComp
    {
        const float minmakefilthvalue = 1.0f;
        //const int ovarypowerthreshold = 72;

        const int tickInterval = GenDate.TicksPerHour;
        const int maxImplantDelayHours = 30 * 24;
        const int minImplantAgeHours = 3 * 24;
        const float pulloutSuccessRate = 0.8f;
        const float fetishPulloutSuccessModifier = 0.25f;

        public CompProperties_Menstruation Props;
        public Stage curStage = Stage.Follicular;
        public int curStageHrs = 0;
        public bool loaded = false;
        public bool initError = false;
        public int ovarypower = -100000;
        public int eggstack = 0;
        public bool DoCleanWomb = false;

        public enum Stage
        {
            Follicular,
            Ovulatory,
            Luteal,
            Bleeding,
            Pregnant,
            Recover,
            None,
            Infertile,
            Anestrus
        }

        public enum EstrusLevel
        {
            None,
            Concealed,
            Visible
        }

        public static readonly Dictionary<Stage, Texture2D> StageTexture = new Dictionary<Stage, Texture2D>()
        {
            { Stage.Follicular, TextureCache.FollicularTexture },
            { Stage.Luteal, TextureCache.LutealTexture },
            { Stage.Bleeding, TextureCache.BleedingTexture },
            { Stage.Pregnant, TextureCache.PregnantTexture },
            { Stage.Recover, TextureCache.RecoverTexture }
        };


        protected List<Cum> cums;
        protected List<Egg> eggs;
        protected float cycleSpeed = -1;
        protected float cycleVariability = -1;
        protected int currentIntervalHours = -1;
        protected float crampPain = -1;
        protected Need sexNeed = null;
        protected string customwombtex = null;
        protected string customvagtex = null;
        protected bool estrusflag = false;
        protected int opcache = -1;
        protected float antisperm = 0.0f;
        protected float? originvagsize = null;
        // RJW pregnancy, or Biotech pregnancy/labor/laborpushing
        protected Hediff pregnancy = null;

        protected int eggLifeSpanHours = 48;
        protected EstrusLevel estrusLevel = EstrusLevel.Visible;
        protected float ovulationFactor = 1f;
        protected bool noBleeding = false;

        private static readonly SimpleCurve SexFrequencyCurve = new SimpleCurve()
        {
            new CurvePoint(0.4f,0.05f),
            new CurvePoint(0.6f,0.1f),
            new CurvePoint(0.8f,0.25f),
            new CurvePoint(1.0f,0.5f)
        };

        private static readonly SimpleCurve SexSatisfactionCurve = new SimpleCurve()
        {
            new CurvePoint(0.4f,0.5f),
            new CurvePoint(0.6f,0.6f),
            new CurvePoint(0.8f,0.7f),
            new CurvePoint(1.0f,0.8f)
        };

        private static readonly SimpleCurve FertilityCurve = new SimpleCurve()
        {
            new CurvePoint(0.4f,0.01f),
            new CurvePoint(0.6f,0.1f),
            new CurvePoint(0.8f,0.25f),
            new CurvePoint(1.0f,0.5f)
        };

        public Hediff Pregnancy {
            get
            {
                if (pregnancy == null) return null;
                else if (!Pawn.health.hediffSet.hediffs.Contains(pregnancy))
                {
                    pregnancy = null;
                    return null;
                }
                else return pregnancy;
            }
            set => pregnancy = value;
        }

        public int OvaryPowerThreshold
        {
            get
            {
                if (opcache > 0) return opcache;
                float avglittersize;
                try
                {
                    avglittersize = Mathf.Max(Rand.ByCurveAverage(Pawn.def.race.litterSizeCurve), 1.0f);
                }
                catch
                {
                    // Any exceptions in that will have been reported elsewhere in the code by now
                    avglittersize = 1.0f;
                };
                avglittersize *= ovulationFactor;
                const float yearsBeforeMenopause = 6.0f;
                opcache = (int)(RaceCyclesPerYear() *
                    avglittersize *
                    yearsBeforeMenopause *
                    (Pawn.def.race.lifeExpectancy / ThingDefOf.Human.race.lifeExpectancy));
                if (opcache == 0) opcache = 1;
                return opcache;
            }
        }

        // >= 1: Normal cycles
        // 1 - 0: Climacteric
        // <= 0: Menopause
        public float EggHealth
        {
            get
            {
                if (!Configurations.EnableMenopause || Props.infertile) return Mathf.Max(1.0f, ovarypower / OvaryPowerThreshold);
                else return (float)ovarypower / OvaryPowerThreshold;
            }
        }

        public float SexFrequencyModifier
        {
            get
            {
                float eggHealth = EggHealth;
                if (eggHealth >= 1) return 1.0f;
                else if (eggHealth <= 0) return 0.01f;
                else return SexFrequencyCurve.Evaluate(eggHealth);
            }
        }

        public float SexSatisfactionModifier
        {
            get
            {
                float eggHealth = EggHealth;
                if (eggHealth >= 1) return 1.0f;
                else if (eggHealth <= 0) return 0.5f;
                else return SexSatisfactionCurve.Evaluate(eggHealth);
            }
        }

        public float FertilityModifier
        {
            get
            {
                float eggHealth = EggHealth;
                if (eggHealth >= 1) return 1.0f;
                else if (eggHealth <= 0) return 0.0f;
                else return FertilityCurve.Evaluate(eggHealth);
            }
        }

        public float TotalCum
        {
            get
            {
                return cums?.Sum(cum => cum.Volume) ?? 0;
            }
        }
        public float TotalFertCum
        {
            get
            {
                return cums?.Sum(cum => cum.FertVolume) ?? 0;
            }
        }
        public float TotalCumPercent
        {
            get
            {
                return cums?.Sum(cum => cum.Volume) / Props.maxCumCapacity ?? 0;
            }
        }
        public float CumCapacity
        {
            get
            {
                float res = Props.maxCumCapacity * Pawn.BodySize;
                if (curStage != Stage.Pregnant || (pregnancy?.Severity ?? 0f) < 0.175f) res *= 500f;
                return res;
            }
        }
        //make follicular interval into half and double egg lifespan
        public float CycleFactor
        {
            get
            {
                if (xxx.has_quirk(Pawn, "Breeder")) return 0.5f;

                return 1.0f;
            }
        }

        // I hate doing this, but it's the least bad option
        public bool calculatingOvulationChance = false;

        public float OvulationChance
        {
            get
            {
                float ovulationChance = 1.0f;
                if (EggHealth <= 0.0f) return 0.0f;
                if (EggHealth < 1.0f / 3.0f) ovulationChance = 0.8f;
                if (ModsConfig.BiotechActive && xxx.is_human(Pawn))
                {
                    if (Pawn.SterileGenes()) return 0.0f;
                    // Replicate how rjw.PawnCapacityWorker_Fertility.CalculateCapacityLevel does it, but without the age factor
                    if (!Pawn.RaceHasFertility()) return 0.0f;
                    if (AndroidsCompatibility.IsAndroid(Pawn) && parent.def != Genital_Helper.archotech_vagina) return 0.0f;
                    foreach (var part in StatDefOf.Fertility.parts)
                    {
                        if(part is StatPart_FertilityByGenderAge fertilityByAge)
                        {
                            float factor = 1.0f;
                            fertilityByAge.TransformValue(StatRequest.For(Pawn), ref factor);
                            if (factor <= 0.0f) return 0.0f;    // Too young or too old
                        }
                        else part.TransformValue(StatRequest.For(Pawn), ref ovulationChance);
                    }
                    if (Pawn.HasQuirk(QuirkUtility.Quirks.Breeder)) ovulationChance *= 10.0f;
                    try
                    {
                        calculatingOvulationChance = true;
                        ovulationChance *= PawnCapacityUtility.CalculateCapacityLevel(Pawn.health.hediffSet, xxx.reproduction);
                    }
                    finally { calculatingOvulationChance = false; }
                }
                return ovulationChance;
            }
        }
        public float ImplantChance
        {
            get
            {
                float factor = 1.0f;
                if (ModsConfig.BiotechActive && xxx.is_human(Pawn))
                {
                    // Implant factor will be based solely on pawn age, plus any rollover from ovulation chance
                    StatPart_FertilityByGenderAge fertilityStatPart = StatDefOf.Fertility.GetStatPart<StatPart_FertilityByGenderAge>();
                    fertilityStatPart?.TransformValue(StatRequest.For(Pawn), ref factor);
                    float ovulationOverflow = OvulationChance;
                    if (ovulationOverflow > 1.0f) factor *= ovulationOverflow;
                    return Props.baseImplantationChanceFactor * FertilityModifier * factor;
                }
                else
                {
                    return Pawn.health.capacities.GetLevel(xxx.reproduction) * Props.baseImplantationChanceFactor * FertilityModifier * factor;
                }
            }
        }

        public IEnumerable<string> GetCumsInfo
        {
            get
            {
                if (cums.NullOrEmpty()) yield return Translations.Info_noCum;
                else foreach (Cum cum in cums)
                    {
                        if (!cum.notcum) yield return string.Format("{0}: {1:0.##}ml", cum.pawn?.Label, cum.Volume);
                        else yield return string.Format("{0}: {1:0.##}ml", cum.notcumLabel, cum.Volume);
                    }
            }
        }
        public Color GetCumMixtureColor
        {
            get
            {
                Color mixedcolor = Color.white;

                if (cums.NullOrEmpty()) return mixedcolor;

                float mixedsofar = 0;
                foreach (Cum cum in cums)
                {
                    if (cum.Volume > 0)
                    {
                        mixedcolor = Colors.CMYKLerp(mixedcolor, cum.Color, cum.Volume / (mixedsofar + cum.Volume));
                        mixedsofar += cum.Volume;
                    }
                }
                return mixedcolor;
            }
        }

        public Stage CurrentVisibleStage
        {
            get
            {
                if (curStage == Stage.Pregnant)
                {
                    if (Configurations.InfoDetail == Configurations.DetailLevel.All || (pregnancy?.Visible ?? false))
                        return Stage.Pregnant;
                    else
                        return Stage.Luteal;
                }
                return curStage;
            }
        }

        public string GetCurStageLabel
        {
            get
            {
                switch (CurrentVisibleStage)
                {
                    case Stage.Follicular:
                        return Translations.Stage_Follicular + (EggHealth < 1f ? " " + Translations.Stage_Climacteric : "");
                    case Stage.Ovulatory:
                        return Translations.Stage_Ovulatory + (EggHealth < 1f ? " " + Translations.Stage_Climacteric : "");
                    case Stage.Luteal:
                        return Translations.Stage_Luteal + (EggHealth < 1f ? " " + Translations.Stage_Climacteric : "");
                    case Stage.Bleeding:
                        return Translations.Stage_Bleeding + (EggHealth < 1f ? " " + Translations.Stage_Climacteric : "");
                    case Stage.Pregnant:
                        return Translations.Stage_Pregnant;
                    case Stage.Recover:
                        return Translations.Stage_Recover;
                    case Stage.None:
                    case Stage.Infertile:
                        if (EggHealth <= 0f) return Translations.Stage_Menopause;
                        else return Translations.Stage_None;
                    case Stage.Anestrus:
                        return Translations.Stage_Anestrus;
                    default:
                        return "";
                }
            }

        }
        public virtual string GetCurStageDesc
        {
            get
            {
                switch (CurrentVisibleStage)
                {
                    case Stage.Follicular:
                        return Translations.Stage_Follicular_Desc + (EggHealth < 1f ? " " + Translations.Stage_Climacteric_Desc : "");
                    case Stage.Ovulatory:
                        return Translations.Stage_Ovulatory_Desc + (EggHealth < 1f ? " " + Translations.Stage_Climacteric_Desc : "");
                    case Stage.Luteal:
                        return Translations.Stage_Luteal_Desc + (EggHealth < 1f ? " " + Translations.Stage_Climacteric_Desc : "");
                    case Stage.Bleeding:
                        return Translations.Stage_Bleeding_Desc + (EggHealth < 1f ? " " + Translations.Stage_Climacteric_Desc : "");
                    case Stage.Pregnant:
                        return Translations.Stage_Pregnant_Desc;
                    case Stage.Recover:
                        return Translations.Stage_Recover_Desc;
                    case Stage.None:
                    case Stage.Infertile:
                        if (EggHealth <= 0f) return Translations.Stage_Menopause_Desc;
                        else return Translations.Stage_None_Desc;
                    case Stage.Anestrus:
                        return Translations.Stage_Anestrus_Desc;
                    default:
                        return "";
                }
            }
        }

        public string WombTex
        {
            get
            {
                return customwombtex ?? Props.wombTex;
            }
            set
            {
                customwombtex = value;
            }
        }
        public string VagTex
        {
            get
            {
                return customvagtex ?? Props.vagTex;
            }
            set
            {
                customvagtex = value;
            }
        }
        public string GetFertilizingInfo
        {
            get
            {
                if (eggs.NullOrEmpty()) return "";

                StringBuilder res = new StringBuilder();
                int fertilized = eggs.Count(egg => egg.fertilized);
                if (fertilized != 0) res.AppendFormat("{0} {1}", fertilized, Translations.Dialog_WombInfo05);
                if (fertilized != 0 && eggs.Count - fertilized != 0) res.Append(", ");
                if (cums.NullOrEmpty() || TotalFertCum == 0)
                {
                    if (eggs.Count - fertilized != 0) res.AppendFormat("{0} {1}", eggs.Count - fertilized, Translations.Dialog_WombInfo07);
                }
                else
                {
                    if (eggs.Count - fertilized != 0) res.AppendFormat("{0} {1}", eggs.Count - fertilized, Translations.Dialog_WombInfo06);
                }
                return res.ToString();
            }
        }
        public bool IsEggFertilizing
        {
            get
            {
                if (eggs.NullOrEmpty()) return false;
                return cums?.Any(cum => cum.FertVolume > 0) ?? false;
            }
        }
        /// <summary>
        /// returns fertstage. if not fertilized returns -1
        /// </summary>
        public int IsFertilized
        {
            get
            {
                if (eggs?.All(egg => !egg.fertilized) ?? true) return -1;
                return eggs.Max(egg => egg.fertstage);
            }
        }
        public IEnumerable<Pawn> GetCummersAndFertilizers()
        {
            if (!cums.NullOrEmpty())
                foreach (Cum cum in cums)
                    yield return cum.pawn;
            if (!eggs.NullOrEmpty())
                foreach (Egg egg in eggs)
                    yield return egg.fertilizer;
        }
        public bool IsEggExist
        {
            get
            {
                return !eggs.NullOrEmpty();
            }
        }

        public int EggLifespanHours
        {
            get
            {
                return eggLifeSpanHours;
            }
        }

        public virtual bool IsDangerDay
        {
            get
            {
                if (Pawn.HasIUD()) return false;

                switch (curStage)
                {
                    case Stage.Follicular:
                        return curStageHrs > 0.7f * currentIntervalHours;
                    case Stage.Ovulatory:
                        return true;
                    case Stage.Luteal:
                        return curStageHrs < EggLifespanHours;
                    default:
                        return false;
                }
            }
        }
        public int GetNumOfEggs
        {
            get
            {
                return eggs?.Count ?? 0;
            }
        }
        public Color BloodColor
        {
            get
            {
                try
                {
                    Color c = Pawn.def.race.BloodDef.graphicData.color;
                    return c;
                }
                catch
                {
                    return Colors.blood;
                }

            }
        }

        public float OriginVagSize
        {
            get
            {
                if (originvagsize == null)
                {
                    originvagsize = parent.Severity;
                }
                return originvagsize ?? 0.1f;
            }
            set
            {
                originvagsize = value;
            }
        }

        public float CurStageIntervalHours
        {
            get
            {
                return currentIntervalHours;
            }
        }

        public float StageProgress
        {
            get
            {
                if (pregnancy == null) return Mathf.Clamp01(curStageHrs / CurStageIntervalHours);
                bool is_discovered = false;
                switch (pregnancy)
                {
                    case Hediff_BasePregnancy rjw_preg:
                        is_discovered = rjw_preg.is_discovered;
                        break;
                    case Hediff_Pregnant vanilla_preg:
                        is_discovered = vanilla_preg.Visible;
                        break;
                    case Hediff_Labor _:
                    case Hediff_LaborPushing _:
                        return 1.0f;
                }

                if (is_discovered || Configurations.infoDetail == Configurations.DetailLevel.All) return pregnancy.Severity;

                // Luteal will appear to progress, hitting the end of the phase when the pregnancy is discovered
                float discoveryTime = 0.5f;
                if (Pawn.story?.bodyType == BodyTypeDefOf.Thin) discoveryTime = 0.25f;
                else if (Pawn.story?.bodyType == BodyTypeDefOf.Female) discoveryTime = 0.35f;
                // Estimated; there's no way to get the exact value after the fact without writing it into the save
                float lutealProgressWhenImplanted = Math.Min(0.5f, maxImplantDelayHours / (Props.lutealIntervalDays * 24));
                
                return GenMath.LerpDouble(0, discoveryTime, lutealProgressWhenImplanted, 1.0f, pregnancy.Severity);
            }
        }

        public Texture2D GetStageTexture
        {
            get
            {
                if (!StageTexture.TryGetValue(CurrentVisibleStage, out Texture2D tex)) tex = TextureCache.PregnantTexture;
                return tex;
            }
        }

        public override void CompExposeData()
        {
            base.CompExposeData();
            Scribe_Collections.Look(ref cums, saveDestroyedThings: true, label: "cums", lookMode: LookMode.Deep, ctorArgs: new object[0]);
            Scribe_Collections.Look(ref eggs, saveDestroyedThings: true, label: "eggs", lookMode: LookMode.Deep, ctorArgs: new object[0]);
            Scribe_Values.Look(ref curStage, "curStage", curStage, true);
            Scribe_Values.Look(ref curStageHrs, "curStageHrs", curStageHrs, true);
            Scribe_Values.Look(ref cycleSpeed, "cycleSpeed", cycleSpeed, true);
            Scribe_Values.Look(ref cycleVariability, "cycleVariability", cycleVariability, true);
            Scribe_Values.Look(ref currentIntervalHours, "currentIntervalHours", currentIntervalHours, true);
            Scribe_Values.Look(ref crampPain, "crampPain", crampPain, true);
            Scribe_Values.Look(ref ovarypower, "ovarypower", ovarypower, true);
            Scribe_Values.Look(ref eggstack, "eggstack", eggstack, true);
            Scribe_Values.Look(ref estrusflag, "estrusflag", estrusflag, true);
            Scribe_Values.Look(ref originvagsize, "originvagsize", originvagsize, true);
            Scribe_Values.Look(ref DoCleanWomb, "DoCleanWomb", DoCleanWomb, true);
            Scribe_References.Look(ref pregnancy, "pregnancy");
        }


        public override void CompPostPostAdd(DamageInfo? dinfo)
        {
            if (!loaded)
            {
                Initialize();
            }
        }

        public void Notify_UpdatedGenes()
        {
            eggLifeSpanHours = Props.eggLifespanDays * 24;
            estrusLevel = Props.concealedEstrus ? EstrusLevel.Concealed : EstrusLevel.Visible;
            ovulationFactor = 1f;
            noBleeding = false;
            
            if (Pawn.genes == null || !ModsConfig.BiotechActive) return;
            
            if (Pawn.genes.HasGene(VariousDefOf.ShortEggLifetime)) eggLifeSpanHours = eggLifeSpanHours * 3 / 4;
            else if (Pawn.genes.HasGene(VariousDefOf.DoubleEggLifetime)) eggLifeSpanHours *= 2;
            else if (Pawn.genes.HasGene(VariousDefOf.QuadEggLifetime)) eggLifeSpanHours *= 4;

            if (Pawn.genes.HasGene(VariousDefOf.NeverEstrus)) estrusLevel = EstrusLevel.None;
            else if (Pawn.genes.HasGene(VariousDefOf.FullEstrus)) estrusLevel = EstrusLevel.Visible;

            if (Pawn.genes.HasGene(VariousDefOf.DoubleOvulation)) ovulationFactor = 2f;
            else if (Pawn.genes.HasGene(VariousDefOf.QuadOvulation)) ovulationFactor = 4f;

            noBleeding = Pawn.genes.HasGene(VariousDefOf.NoBleeding);
        }

        public bool ShouldSimulate()
        {
            if (!Configurations.EnableAnimalCycle && Pawn.IsAnimal()) return false;
            if (Pawn.Spawned || Pawn.IsCaravanMember() || PawnUtility.IsTravelingInTransportPodWorldObject(Pawn)) return true;

            return false;
        }

        public bool ShouldBeInfertile()
        {
            if (pregnancy != null) return false;
            if (ImplantChance <= 0.0f) return true;
            // Give the last egg ovulated a chance to implant
            if (curStage == Stage.Luteal || curStage == Stage.Bleeding || curStage == Stage.Recover) return false;
            if (EggHealth <= 0.0f) return true;
            return false;
        }

        public override void CompPostTick(ref float severityAdjustment)
        {
            base.CompPostTick(ref severityAdjustment);
            // If an exception makes it out, RW will remove the hediff, so catch it here
            try
            {
                if (!ShouldSimulate()) return;

                // Initialize immediately if needed, but if there's an error, then don't spam it every tick
                if (!loaded && !initError)
                {
                    Log.Warning($"{Pawn}'s womb is ticking, but was not initialized first");
                    Initialize();
                }

                if (!Pawn.IsHashIntervalTick(tickInterval)) return;
                
                if (initError) Log.Warning($"Attempting to process {Pawn}'s womb uninitialized");

                if (Pregnancy != null && curStage != Stage.Pregnant)
                {
                    Log.Warning($"{Pawn}'s womb has a pregnancy, but was not in the pregnant stage");
                    GoNextStage(Stage.Pregnant);
                }

                BeforeSimulator();
                
                if (ShouldBeInfertile()) GoNextStage(Stage.Infertile);
                switch (curStage)
                {
                    case Stage.Follicular:
                        FollicularAction();
                        break;
                    case Stage.Ovulatory:
                        OvulatoryAction();
                        break;
                    case Stage.Luteal:
                        LutealAction();
                        break;
                    case Stage.Bleeding:
                        BleedingAction();
                        break;
                    case Stage.Pregnant:
                        PregnantAction();
                        break;
                    case Stage.Recover:
                        RecoverAction();
                        break;
                    case Stage.None:
                        break;
                    case Stage.Infertile:
                        InfertileAction();
                        break;
                    case Stage.Anestrus:
                        AnestrusAction();
                        break;
                    default:
                        GoNextStage(Stage.Follicular);
                        break;
                }
                AfterSimulator();
            }
            catch (Exception ex)
            {
                Log.Error($"Error processing womb of {Pawn}: {ex}");
            }
        }

        public override void CompPostPostRemoved()
        {
            // If a hediff is removed from a pawn that does not have it, CompPostPostRemoved is still called on the pawn that does.
            // If it was a legitimate removal, then it won't be in this pawn's hediff list anymore, as that removal occurs first
            if (Pawn.health.hediffSet.hediffs.Contains(parent))
            {
                Log.Warning($"Attempted to remove menstruation comp from wrong pawn ({Pawn}).");
                return;
            }
            switch (pregnancy)
            {
                case null:
                case Hediff_MechanoidPregnancy _:
                    break;
                case Hediff_BasePregnancy rjw_preg:
                    rjw_preg.Miscarry();
                    break;
                case Hediff_Pregnant vanilla_preg:
                    Pawn.health.RemoveHediff(vanilla_preg);
                    break;
            }

            base.CompPostPostRemoved();
        }

        public override string CompTipStringExtra
        {
            get
            {
                StringBuilder tip = new StringBuilder();
                tip.Append(Translations.Dialog_WombInfo01);
                tip.Append(": ");
                tip.Append(GetCurStageLabel);
                string fertInfo = GetFertilizingInfo;
                if(CurrentVisibleStage == Stage.Luteal && fertInfo.Length > 0)
                {
                    tip.AppendLine();
                    tip.Append(fertInfo);
                }
                return tip.ToString();
            }
        }

        protected virtual int HoursToNextStage()
        {
            return Math.Max(0,(currentIntervalHours - curStageHrs) / Configurations.CycleAcceleration);
        }

        public override string CompDebugString()
        {
            if (curStage == Stage.None || curStage == Stage.Infertile || curStage == Stage.Pregnant) return base.CompDebugString();
            StringBuilder debugString = new StringBuilder();
            debugString.Append($"Time to next state: ");
            debugString.Append(GenDate.ToStringTicksToPeriod(HoursToNextStage() * GenDate.TicksPerHour));
            return debugString.ToString();
        }

        /// <summary>
        /// Get fluid in womb that not a cum
        /// </summary>
        /// <param name="notcumlabel"></param>
        /// <returns></returns>
        public Cum GetNotCum(string notcumlabel)
        {
            if (!cums.NullOrEmpty()) foreach (Cum cum in cums)
                {
                    if (cum.notcum && cum.notcumLabel.Equals(notcumlabel)) return cum;
                }
            return null;
        }

        /// <summary>
        /// Get pawn's cum in womb
        /// </summary>
        /// <param name="pawn"></param>
        /// <returns></returns>
        public Cum GetCum(Pawn pawn)
        {
            return cums?.Find(cum => !cum.notcum && cum.pawn == pawn);
        }

        /// <summary>
        /// Inject pawn's cum into womb
        /// </summary>
        /// <param name="pawn"></param>
        /// <param name="volume"></param>
        /// <param name="fertility"></param>
        /// <param name="precum"></param>
        public void CumIn(Pawn pawn, float volume, float fertility = 1.0f, bool precum = false)
        {
            if (volume <= 0) return;
            if (!precum && fertility > 0 && IsDangerDay && pawn.relations.GetPregnancyApproachForPartner(Pawn) == PregnancyApproach.AvoidPregnancy)
            {
                float successChance = pulloutSuccessRate;
                if (pawn.HasQuirk(QuirkUtility.Quirks.ImpregnationFetish)) successChance *= fetishPulloutSuccessModifier;
                if (Pawn.HasQuirk(QuirkUtility.Quirks.ImpregnationFetish)) successChance *= fetishPulloutSuccessModifier;
                if (Rand.Chance(successChance)) return;
            }
            if (Pawn.HasIUD()) fertility /= 100f;
            float cumd = TotalCumPercent;
            float tmp = TotalCum + volume;
            if (tmp > CumCapacity)
            {
                float cumoutrate = 1 - (CumCapacity / tmp);
                bool merged = false;
                if (!cums.NullOrEmpty()) foreach (Cum cum in cums)
                    {
                        if (cum.pawn.Equals(pawn))
                        {
                            cum.MergeWithCum(volume, fertility);
                            merged = true;
                        }
                        cum.DismishForce(cumoutrate);
                    }
                if (!merged) cums.Add(new Cum(pawn, volume * (1 - cumoutrate), fertility));
            }
            else
            {

                bool merged = false;
                if (!cums.NullOrEmpty()) foreach (Cum cum in cums)
                    {
                        if (cum.pawn.Equals(pawn))
                        {
                            cum.MergeWithCum(volume, fertility);
                            merged = true;
                        }
                    }
                if (!merged) cums.Add(new Cum(pawn, volume, fertility));
            }
            cumd = TotalCumPercent - cumd;

            if (!precum)
            {
                Pawn.records.AddTo(VariousDefOf.AmountofCreampied, volume);
                AfterCumIn(pawn);
                AfterFluidIn(cumd);
            }
        }

        /// <summary>
        /// Inject pawn's fluid into womb
        /// </summary>
        /// <param name="pawn"></param>
        /// <param name="volume"></param>
        /// <param name="notcumlabel"></param>
        /// <param name="decayresist"></param>
        /// <param name="filthdef"></param>
        public void CumIn(Pawn pawn, float volume, string notcumlabel, float decayresist = 0, ThingDef filthdef = null)
        {
            if (volume <= 0) return;
            float tmp = TotalCum + volume;
            float cumd = TotalCumPercent;
            if (tmp > CumCapacity)
            {
                float cumoutrate = 1 - (CumCapacity / tmp);
                bool merged = false;
                if (!cums.NullOrEmpty()) foreach (Cum cum in cums)
                    {
                        if (cum.notcum && cum.pawn.Equals(pawn) && cum.notcumLabel.Equals(notcumlabel))
                        {
                            cum.MergeWithFluid(volume, decayresist, filthdef);
                            merged = true;
                        }
                        cum.DismishForce(cumoutrate);
                    }
                if (!merged) cums.Add(new Cum(pawn, volume * (1 - cumoutrate), notcumlabel, decayresist, filthdef));
            }
            else
            {

                bool merged = false;
                if (!cums.NullOrEmpty()) foreach (Cum cum in cums)
                    {
                        if (cum.notcum && cum.pawn.Equals(pawn) && cum.notcumLabel.Equals(notcumlabel))
                        {
                            cum.MergeWithFluid(volume, decayresist, filthdef);
                            merged = true;
                        }
                    }
                if (!merged) cums.Add(new Cum(pawn, volume, notcumlabel, decayresist, filthdef));
            }
            cumd = TotalCumPercent - cumd;
            AfterNotCumIn();
            AfterFluidIn(cumd);
        }

        protected virtual void AfterCumIn(Pawn cummer)
        {
            ThoughtCumInside(cummer);
            TaleCumInside(cummer);
        }

        protected virtual void AfterNotCumIn()
        {

        }

        /// <summary>
        /// Action for both Cum and NotCum
        /// </summary>
        /// <param name="fd">Fluid deviation</param>
        protected virtual void AfterFluidIn(float fd)
        {


        }


        protected void BeforeCumOut(out Absorber absorber)
        {
            Hediff asa = Pawn.health.hediffSet.GetFirstHediffOfDef(VariousDefOf.Hediff_ASA);
            float asafactor = asa?.Severity ?? 0f;

            if (Pawn.HasIUD()) antisperm = 0.70f + asafactor;
            else antisperm = 0.0f + asafactor;

            absorber = (Absorber)Pawn.apparel?.WornApparel?.Find(x => x is Absorber);
            if (absorber != null)
            {
                absorber.WearEffect();
                if (absorber.dirty && absorber.EffectAfterDirty) absorber.DirtyEffect();
            }
        }

        /// <summary>
        /// For natural leaking
        /// </summary>
        protected virtual void AfterCumOut()
        {
            Pawn.needs?.mood?.thoughts?.memories?.TryGainMemory(VariousDefOf.LeakingFluids);
        }

        /// <summary>
        /// For all type of leaking
        /// </summary>
        /// <param name="fd"></param>
        protected virtual void AfterFluidOut(float fd)
        {

        }




        /// <summary>
        /// Excrete cums in womb naturally
        /// </summary>
        public void CumOut()
        {
            float leakfactor = 1.0f;
            float totalleak = 0f;
            float cumd = TotalCumPercent;
            List<string> filthlabels = new List<string>();
            BeforeCumOut(out Absorber absorber);
            if (cums.NullOrEmpty()) return;
            if (TotalCum > Props.maxCumCapacity * Pawn.BodySize) leakfactor = Math.Min(1 + (TotalCum - Props.maxCumCapacity * Pawn.BodySize) / 10, 2f);
            if (absorber != null && absorber.dirty && !absorber.LeakAfterDirty) leakfactor = 0f;
            if (Pawn.CurJobDef == xxx.knotted) leakfactor = 0f;
            HashSet<Cum> removecums = new HashSet<Cum>();
            foreach (Cum cum in cums)
            {
                cum.CumEffects(Pawn);
                float vd = cum.DismishNatural(leakfactor, this, antisperm);
                cum.MakeThinner(Configurations.CycleAcceleration);
                totalleak += AbsorbCum(vd, absorber);
                string tmp = "FilthLabelWithSource".Translate(cum.FilthDef.label, cum.pawn?.LabelShort ?? "Unknown", 1.ToString());
                filthlabels.Add(tmp.Replace(" x1", ""));
                if (cum.ShouldRemove()) removecums.Add(cum);
            }
            if (cums.Count > 1) MakeCumFilthMixture(totalleak, filthlabels);
            else if (cums.Count == 1) MakeCumFilth(cums.First(), totalleak);
            cums.RemoveAll(cum => removecums.Contains(cum));
            cumd = TotalCumPercent - cumd;
            if (totalleak >= 1.0f) AfterCumOut();
            AfterFluidOut(cumd);

        }

        /// <summary>
        /// Force excrete cums in womb and get excreted amount of specific cum.
        /// </summary>
        /// <param name="targetcum"></param>
        /// <param name="portion"></param>
        /// <returns>Amount of target cum</returns>
        public float CumOut(Cum targetcum, float portion = 0.1f)
        {
            if (cums.NullOrEmpty()) return 0;
            float totalleak = 0;
            List<string> filthlabels = new List<string>();
            float outcum = 0;
            float cumd = TotalCumPercent;
            HashSet<Cum> removecums = new HashSet<Cum>();
            foreach (Cum cum in cums)
            {
                float vd = cum.DismishForce(portion);
                if (cum.Equals(targetcum)) outcum = vd;
                //MakeCumFilth(cum, vd - cum.volume);
                string tmp = "FilthLabelWithSource".Translate(cum.FilthDef.label, cum.pawn?.LabelShort ?? "Unknown", 1.ToString());
                filthlabels.Add(tmp.Replace(" x1", ""));
                totalleak += vd;
                if (cum.ShouldRemove()) removecums.Add(cum);
            }
            if (cums.Count > 1) MakeCumFilthMixture(totalleak, filthlabels);
            else if (cums.Count == 1) MakeCumFilth(cums.First(), totalleak);
            cums.RemoveAll(cum => removecums.Contains(cum));
            cumd = TotalCumPercent - cumd;
            AfterFluidOut(cumd);
            return outcum;
        }

        /// <summary>
        /// Force excrete cums in womb and get mixture of cum.
        /// </summary>
        /// <param name="mixtureDef"></param>
        /// <param name="portion"></param>
        /// <returns></returns>
        public CumMixture MixtureOut(ThingDef mixtureDef, float portion = 0.1f)
        {
            if (cums.NullOrEmpty()) return null;
            Color color = GetCumMixtureColor;
            float totalleak = 0;
            List<string> cumlabels = new List<string>();
            HashSet<Cum> removecums = new HashSet<Cum>();
            bool pure = true;
            foreach (Cum cum in cums)
            {
                float vd = cum.DismishForce(portion);
                string tmp = "FilthLabelWithSource".Translate(cum.FilthDef.label, cum.pawn?.LabelShort ?? "Unknown", 1.ToString());
                cumlabels.Add(tmp.Replace(" x1", ""));
                totalleak += vd;
                if (cum.ShouldRemove()) removecums.Add(cum);
                if (cum.notcum) pure = false;
            }
            cums.RemoveAll(cum => removecums.Contains(cum));
            return new CumMixture(Pawn, totalleak, cumlabels, color, mixtureDef, pure);
        }

        /// <summary>
        /// Debug: Remove all cums from a womb
        /// </summary>
        /// <returns></returns>
        public void RemoveAllCums()
        {
            cums.Clear();
        }


        /// <summary>
        /// Fertilize eggs and return the result
        /// </summary>
        /// <returns></returns>
        protected void FertilizationCheck()
        {
            if (eggs.NullOrEmpty()) return;
            foreach (Egg egg in eggs)
            {
                if (!egg.fertilized) egg.fertilizer = Fertilize();
                if (egg.fertilizer != null)
                {
                    egg.fertilized = true;
                }
            }
        }

        public void Initialize()
        {
            initError = true;
            Props = (CompProperties_Menstruation)props;

            Notify_UpdatedGenes();

            if (Props.infertile)
            {
                if (cums == null) cums = new List<Cum>();
                curStage = Stage.None;
                loaded = true;
                initError = false;
                return;
            }

            if (cycleSpeed < 0f) cycleSpeed = Utility.RandGaussianLike(0.8f, 1.2f);
            if (cycleVariability < 0f) cycleVariability = MenstruationUtility.RandomVariabilityPercent();
            
            InitOvary();

            if (currentIntervalHours < 0)
            {
                if (ShouldBeInfertile()) curStage = Stage.Infertile;
                else if (!IsBreedingSeason()) curStage = Stage.Anestrus;
                else curStage = RandomStage();
                if (curStage == Stage.Follicular)
                    currentIntervalHours = PeriodRandomizer(Stage.Follicular) - PeriodRandomizer(Stage.Bleeding);
                else
                    currentIntervalHours = PeriodRandomizer(curStage);
                if (currentIntervalHours <= 0) currentIntervalHours = 1;
                else if (currentIntervalHours < curStageHrs) curStageHrs = currentIntervalHours;
            }
            if (crampPain < 0) crampPain = PainRandomizer();
            InitializeExtraValues();
            if (cums == null) cums = new List<Cum>();
            if (eggs == null) eggs = new List<Egg>();

            TakeLoosePregnancy();

            //Log.Message(Pawn.Label + " - Initialized menstruation comp");
            loaded = true;
            initError = false;
        }

        protected virtual void InitializeExtraValues()
        {
        }

        protected virtual float RaceCyclesPerYear()
        {
            int breedingSeasons = 0;
            if (Props.breedingSeason == SeasonalBreed.Always) breedingSeasons = 4;
            else
            {
                if ((Props.breedingSeason & SeasonalBreed.Spring) != 0) breedingSeasons++;
                if ((Props.breedingSeason & SeasonalBreed.Summer) != 0) breedingSeasons++;
                if ((Props.breedingSeason & SeasonalBreed.Fall) != 0) breedingSeasons++;
                if ((Props.breedingSeason & SeasonalBreed.Winter) != 0) breedingSeasons++;
            }
            float breedingRatio = breedingSeasons / 4.0f;
            return breedingRatio * GenDate.DaysPerYear / ((float)(Props.follicularIntervalDays + Props.lutealIntervalDays) / Configurations.CycleAccelerationDefault);
        }

        protected virtual int PawnEggsUsed(float pawnCyclesElapsed, float avglittersize)
        {
            return (int)(pawnCyclesElapsed * avglittersize);
        }

        public int GetOvaryPowerByAge()
        {
            float avglittersize;
            try
            {
                avglittersize = Mathf.Max(Rand.ByCurveAverage(Pawn.def.race.litterSizeCurve), 1.0f);
            }
            catch (NullReferenceException)
            {
                avglittersize = 1.0f;
            }
            avglittersize *= ovulationFactor;

            float fertStartAge = Pawn.RaceProps.lifeStageAges?.Find(stage => stage.def.reproductive)?.minAge ?? 0.0f;
            float fertEndAge = Pawn.RaceProps.lifeExpectancy * (Pawn.IsAnimal() ? RJWPregnancySettings.fertility_endage_female_animal : RJWPregnancySettings.fertility_endage_female_humanlike);
            if (fertEndAge < fertStartAge) fertEndAge = fertStartAge;

            float raceCyclesPerYear = RaceCyclesPerYear();
            int lifetimeCycles = (int)(raceCyclesPerYear * (fertEndAge - fertStartAge));
            int lifetimeEggs = (int)(lifetimeCycles * avglittersize * Props.eggMultiplier * Utility.RandGaussianLike(0.70f, 1.30f, 5));

            float pawnCyclesPerYear = raceCyclesPerYear * cycleSpeed;
            float pawnCyclesElapsed = Mathf.Max((Pawn.ageTracker.AgeBiologicalYearsFloat - fertStartAge) * pawnCyclesPerYear, 0.0f);
            int pawnEggsUsed = PawnEggsUsed(pawnCyclesElapsed, avglittersize);

            return Math.Max(lifetimeEggs - pawnEggsUsed, 0);
        }

        protected void InitOvary()
        {
            if (ovarypower < -50000)
            {
                ovarypower = GetOvaryPowerByAge();
                if (Props.infertile) curStage = Stage.None;
                else if (ovarypower < 1)
                {
                    curStage = Stage.Infertile;
                }
            }
        }

        public void RecoverOvary(float multiply = 1.2f)
        {
            ovarypower = Math.Max(0, (int)(ovarypower * multiply));
        }

        protected virtual void BeforeSimulator()
        {
            CumOut();
        }

        protected virtual void AfterSimulator()
        {
            if (EggHealth < 1f)
            {
                if (sexNeed == null) sexNeed = Pawn.needs.TryGetNeed(VariousDefOf.SexNeed);
                if (sexNeed?.CurLevel < 0.5) sexNeed.CurLevel += 0.01f / Math.Max(1, Pawn.GetMenstruationComps().Count());
            }
        }

        protected virtual bool ShouldBeInEstrus()
        {
            if (!loaded)
                Initialize();
            switch (curStage)
            {
                case Stage.Follicular:
                    return curStageHrs > currentIntervalHours - Props.estrusDaysBeforeOvulation * 24;
                case Stage.Ovulatory:
                    return true;
                case Stage.Luteal:
                    return curStageHrs < EggLifespanHours;
                default:
                    return false;
            }
        }

        public EstrusLevel GetEstrusLevel()
        {
            if (!ShouldBeInEstrus()) return EstrusLevel.None;
            else return estrusLevel;
        }

        public void SetEstrus()
        {
            if (estrusLevel == EstrusLevel.None) return;
            Hediff hediff = HediffMaker.MakeHediff(estrusLevel == EstrusLevel.Concealed ? VariousDefOf.Hediff_Estrus_Concealed : VariousDefOf.Hediff_Estrus, Pawn);
            Pawn.health.AddHediff(hediff);
        }

        public bool IsBreedingSeason()
        {
            if (Props.breedingSeason == SeasonalBreed.Always) return true;

            int tile = Pawn.Tile;
            if (tile < 0) tile = Find.AnyPlayerHomeMap?.Tile ?? -1;
            if (tile < 0) return true;
            switch (GenLocalDate.Season(tile))
            {
                case Season.Spring:
                    return (Props.breedingSeason & SeasonalBreed.Spring) != 0;
                case Season.Summer:
                case Season.PermanentSummer:
                    return (Props.breedingSeason & SeasonalBreed.Summer) != 0;
                case Season.Fall:
                    return (Props.breedingSeason & SeasonalBreed.Fall) != 0;
                case Season.Winter:
                case Season.PermanentWinter:
                    return (Props.breedingSeason & SeasonalBreed.Winter) != 0;
                default:
                    return false;
            }
        }

        protected Pawn Fertilize()
        {
            if (cums.NullOrEmpty()) return null;
            List<Cum> eligibleCum = cums.FindAll(cum => !cum.notcum && cum.FertVolume > 0 && cum.pawn != null && (RJWPregnancySettings.bestial_pregnancy_enabled || xxx.is_animal(Pawn) == xxx.is_animal(cum.pawn)));
            if (eligibleCum.Count == 0) return null;

            float totalFertPower = eligibleCum.Sum(cum => cum.FertVolume);
            
            if (Rand.Chance(Mathf.Pow(1.0f - Configurations.FertilizeChance, totalFertPower * Props.basefertilizationChanceFactor)))
                return null;

            Pawn.records.AddTo(VariousDefOf.AmountofFertilizedEggs, 1);
            float selection = Rand.Range(0.0f, totalFertPower);

            foreach (Cum cum in eligibleCum)
            {
                selection -= cum.FertVolume;
                if (selection <= 0) return cum.pawn;
            }

            // We shouldn't reach here, but floating point errors exist, so just to be sure, select whomever came the most
            return eligibleCum.MaxBy(cum => cum.FertVolume).pawn;
        }


        protected bool Implant()
        {
            if (eggs.NullOrEmpty()) return false;

            HashSet<Egg> deadeggs = new HashSet<Egg>();
            bool pregnant = false;
            foreach (Egg egg in eggs)
            {
                if (!egg.fertilized ||
                    egg.fertstage < minImplantAgeHours ||
                    egg.position < Math.Min(Props.lutealIntervalDays * 24 / 2, maxImplantDelayHours))
                    continue;
                else if (egg.fertilizer == null)
                {
                    if (Configurations.Debug) Log.Message($"Could not implant {Pawn}'s egg due to null father");
                    deadeggs.Add(egg);
                    continue;
                }
                else if (Pawn.health.hediffSet.GetFirstHediff<Hediff_InsectEgg>() != null || pregnancy is Hediff_MechanoidPregnancy)
                {
                    if (Configurations.Debug) Log.Message($"Could not implant {Pawn}'s egg due to insect or mechanoid pregnancy");
                    deadeggs.Add(egg);
                    continue;
                }
                else if (Rand.Chance(Configurations.ImplantationChance * ImplantChance * InterspeciesImplantFactor(egg.fertilizer)))
                {
                    if (Configurations.Debug) Log.Message($"Implanting fertilized egg of {Pawn} into {parent}, father {egg.fertilizer}");
                    if (pregnancy != null)
                    {
                        if (Configurations.PregnancySource == Configurations.PregnancyType.Biotech && Configurations.EnableBiotechTwins && Configurations.EnableHeteroOvularTwins)
                        {
                            if (Configurations.Debug) Log.Message($"Adding to existing Biotech pregnancy {pregnancy}");
                            HediffComp_PregeneratedBabies comp = pregnancy.TryGetComp<HediffComp_PregeneratedBabies>();
                            if (comp == null) Log.Warning($"Trying to add Biotech egg to {Pawn}'s pregnancy without a pregenerated baby comp: {pregnancy}");
                            else
                            {
                                comp.AddNewBaby(Pawn, egg.fertilizer);
                                pregnant = true;
                                deadeggs.Add(egg);
                            }
                        }
                        else if (Configurations.PregnancySource == Configurations.PregnancyType.MultiplePregnancy && Configurations.EnableHeteroOvularTwins)
                        {
                            if (pregnancy is Hediff_MultiplePregnancy h)
                            {
                                if (Configurations.Debug) Log.Message($"Adding to existing pregnancy {h}");
                                h.AddNewBaby(Pawn, egg.fertilizer);
                            }
                            pregnant = true;
                            deadeggs.Add(egg);
                        }
                        else
                        {
                            pregnant = true;
                            break;
                        }
                    }
                    else
                    {
                        Configurations.PregnancyType usePregnancy = xxx.is_human(Pawn) ? Configurations.PregnancySource : Configurations.PregnancyType.MultiplePregnancy;
                        switch (usePregnancy)
                        {
                            case Configurations.PregnancyType.BaseRJW:
                                
                                if (Configurations.Debug) Log.Message($"Creating new base RJW pregnancy");
                                PregnancyHelper.AddPregnancyHediff(Pawn, egg.fertilizer);
                                // I hate having to do this, but it gets the newest pregnancy
                                List<Hediff_BasePregnancy> pregnancies = new List<Hediff_BasePregnancy>();
                                Pawn.health.hediffSet.GetHediffs(ref pregnancies);
                                pregnancy = pregnancies.MaxBy(hediff => hediff.loadID);
                                pregnant = true;
                                break;                                

                            case Configurations.PregnancyType.MultiplePregnancy:
                                if (Configurations.Debug) Log.Message($"Creating new menstruation pregnancy");
                                pregnancy = Hediff_BasePregnancy.Create<Hediff_MultiplePregnancy>(Pawn, egg.fertilizer);
                                pregnant = true;
                                deadeggs.Add(egg);
                                break;

                            case Configurations.PregnancyType.Biotech:
                                if (Configurations.Debug) Log.Message($"Creating new biotech pregnancy");
                                pregnancy = HediffMaker.MakeHediff(HediffDefOf.PregnantHuman, Pawn);
                                if(Configurations.EnableBiotechTwins)
                                    pregnancy.TryGetComp<HediffComp_PregeneratedBabies>().AddNewBaby(Pawn, egg.fertilizer);
                                ((Hediff_Pregnant)pregnancy).SetParents(Pawn, egg.fertilizer, PregnancyUtility.GetInheritedGeneSet(egg.fertilizer, Pawn));
                                Pawn.health.AddHediff(pregnancy);
                                pregnant = true;
                                deadeggs.Add(egg);
                                break;
                        }
                        if (pregnancy is Hediff_BasePregnancy rjw_preg)
                        {
                            // TODO: advance biotech pregnancy
                            rjw_preg.p_start_tick -= egg.fertstage / Configurations.CycleAcceleration * GenDate.TicksPerHour;
                            rjw_preg.p_end_tick -= egg.fertstage / Configurations.CycleAcceleration * GenDate.TicksPerHour;
                        }
                    }
                }
                else
                {
                    if (Configurations.Debug) Log.Message($"Fertilized egg of {Pawn} failed to implant (father {egg.fertilizer})");
                    deadeggs.Add(egg);
                }
            }

            if (pregnant &&
                (Configurations.PregnancySource != Configurations.PregnancyType.MultiplePregnancy || !Configurations.EnableHeteroOvularTwins) &&
                (Configurations.PregnancySource != Configurations.PregnancyType.Biotech || !Configurations.EnableBiotechTwins || !Configurations.EnableHeteroOvularTwins))
            {
                eggs.Clear();
                return true;
            }
            else
                eggs.RemoveAll(egg => deadeggs.Contains(egg));
            return pregnant;
        }

        protected void BleedOut()
        {
            CumIn(Pawn, Rand.Range(0.02f * Configurations.BleedingAmount, 0.04f * Configurations.BleedingAmount), Translations.Menstrual_Blood, -5.0f, Pawn.def.race?.BloodDef ?? ThingDefOf.Filth_Blood);
            Cum blood = GetNotCum(Translations.Menstrual_Blood);
            if (blood != null) blood.Color = BloodColor;
        }

        /// <summary>
        /// Make filth ignoring absorber
        /// </summary>
        /// <param name="cum"></param>
        /// <param name="amount"></param>
        protected void MakeCumFilth(Cum cum, float amount)
        {
            if (Pawn.Map == null) return;
            if (amount >= minmakefilthvalue) FilthMaker.TryMakeFilth(Pawn.Position, Pawn.Map, cum.FilthDef, cum.pawn?.LabelShort ?? "Unknown");
        }

        /// <summary>
        /// Absorb cum and return leaked amount
        /// </summary>
        /// <param name="amount"></param>
        /// <param name="absorber"></param>
        /// 
        /// <returns></returns>
        protected float AbsorbCum(float amount, Absorber absorber)
        {

            if (absorber == null)
            {
                //if (amount >= minmakefilthvalue) FilthMaker.TryMakeFilth(Pawn.Position, Pawn.Map, cum.FilthDef, cum.pawn.LabelShort);
                return amount;
            }

            float absorbable = absorber.GetStatValue(VariousDefOf.MaxAbsorbable);
            absorber.SetColor(Colors.CMYKLerp(GetCumMixtureColor, absorber.DrawColor, 1f - amount / absorbable));
            if (absorber.dirty)
            {
                //if (absorber.LeakAfterDirty) FilthMaker.TryMakeFilth(Pawn.Position, Pawn.Map, cum.FilthDef, cum.pawn.LabelShort);
                return amount;
            }
            absorber.absorbedfluids += amount;
            if (absorber.absorbedfluids > absorbable && !Pawn.apparel.IsLocked(absorber))
            {
                absorber.def = absorber.DirtyDef;
                //absorber.fluidColor = GetCumMixtureColor;
                absorber.dirty = true;
            }
            return 0;
        }

        protected float MakeCumFilthMixture(float amount, List<string> cumlabels)
        {
            if (Pawn.Map == null) return 0;
            if (amount >= minmakefilthvalue)
            {
                FilthMaker_Colored.TryMakeFilth(Pawn.Position, Pawn.Map, VariousDefOf.FilthMixture, cumlabels, GetCumMixtureColor, false);
            }
            return amount;
        }




        protected void EggDecay()
        {
            HashSet<Egg> deadeggs = new HashSet<Egg>();
            foreach (Egg egg in eggs)
            {
                egg.position += Configurations.CycleAcceleration;
                if (egg.fertilized) egg.fertstage += Configurations.CycleAcceleration;
                else
                {
                    egg.lifespanhrs -= Configurations.CycleAcceleration;
                    if (egg.lifespanhrs < 0) deadeggs.Add(egg);
                }
            }
            eggs.RemoveAll(egg => deadeggs.Contains(egg));
        }

        protected void AddCrampPain()
        {
            Hediff hediff = HediffMaker.MakeHediff(VariousDefOf.Hediff_MenstrualCramp, Pawn);
            hediff.Severity = crampPain * Rand.Range(0.9f, 1.1f);
            HediffCompProperties_SeverityPerDay Prop = (HediffCompProperties_SeverityPerDay)hediff.TryGetComp<HediffComp_SeverityPerDay>().props;
            Prop.severityPerDay = -hediff.Severity / (currentIntervalHours / 24) * Configurations.CycleAcceleration;
            Pawn.health.AddHediff(hediff, Genital_Helper.get_genitalsBPR(Pawn));
        }

        protected virtual void FollicularAction()
        {
            if (!IsBreedingSeason())
            {
                estrusflag = false;
                GoNextStage(Stage.Anestrus);
                return;
            }
            else if (curStageHrs >= currentIntervalHours)
            {
                GoOvulatoryStage();
            }
            else
            {
                curStageHrs += Configurations.CycleAcceleration;
                if (!estrusflag && curStageHrs > currentIntervalHours - Props.estrusDaysBeforeOvulation * 24)
                {
                    estrusflag = true;
                    SetEstrus();
                }
                StayCurrentStage();
            }
        }

        protected virtual void OvulatoryAction()
        {
            estrusflag = false;
            float eggnum;
            try
            {
                eggnum = Math.Max(Rand.ByCurve(Pawn.def.race.litterSizeCurve), 1f);
            }
            catch (NullReferenceException)
            {
                eggnum = 1f;
            }
            catch (ArgumentException e)
            {
                Log.Warning($"Invalid litterSizeCurve for {Pawn.def}: {e}");
                eggnum = 1f;
            }
            eggnum *= ovulationFactor;
            int toOvulate = (int)eggnum + eggstack;

            float ovulationChance = OvulationChance;
            int ovulated = 0;
            for (int i = 0; i < toOvulate; i++)
                if (i < eggstack || Rand.Chance(ovulationChance))   // eggstack comes from drugs and are guaranteed ovulated
                {
                    eggs.Add(new Egg((int)(EggLifespanHours / CycleFactor)));
                    ++ovulated;
                }

            ovarypower -= ovulated;
            eggstack = 0;
            if (Configurations.Debug && ovulated != toOvulate)
                Log.Message($"{Pawn} ovulated {ovulated}/{toOvulate} eggs ({ovulationChance.ToStringPercent()} chance)");

            GoNextStage(Stage.Luteal);
        }

        protected virtual void LutealAction()
        {
            if (curStageHrs >= currentIntervalHours)
            {
                eggs.Clear();
                if (EggHealth < 1f / 4f || (EggHealth < 1f / 3f && Rand.Chance(0.3f))) //skips bleeding
                {
                    GoNextStage(Stage.Follicular);
                }
                else
                {
                    GoFollicularOrBleeding();
                }
            }
            else if (!eggs.NullOrEmpty())
            {
                FertilizationCheck();
                EggDecay();
                if (Implant())
                {
                    GoNextStage(Stage.Pregnant);
                }
                else
                {
                    curStageHrs += Configurations.CycleAcceleration;
                    StayCurrentStage();
                }
            }
            else
            {
                curStageHrs += Configurations.CycleAcceleration;
                StayCurrentStage();
            }

        }

        protected virtual void BleedingAction()
        {
            if (curStageHrs >= currentIntervalHours)
            {
                Hediff hediff = Pawn.health.hediffSet.GetFirstHediffOfDef(VariousDefOf.Hediff_MenstrualCramp);
                if (hediff != null && !Pawn.GetMenstruationComps().Any(comp => comp != this && comp.curStage == Stage.Bleeding)) Pawn.health.RemoveHediff(hediff);
                int totalFollicularHours = PeriodRandomizer(Stage.Follicular);  // The total amount of time for both bleeding and follicular
                if (totalFollicularHours <= currentIntervalHours)   // We've bled for so long that we completely missed the follicular phase
                    GoOvulatoryStage();
                else
                {
                    currentIntervalHours = totalFollicularHours - currentIntervalHours; // I.e., the remaining follicular hours equals the total minus the bleeding hours elapsed
                    GoNextStage(Stage.Follicular, false);
                }
            }
            else
            {
                if (curStageHrs < currentIntervalHours / 4) for (int i = 0; i < Configurations.CycleAcceleration; i++) BleedOut();
                curStageHrs += Configurations.CycleAcceleration;
                StayCurrentStage();
            }
        }

        protected virtual void PregnantAction()
        {
            if (!eggs.NullOrEmpty())
            {
                FertilizationCheck();
                EggDecay();
                Implant();
            }

            if (pregnancy != null && Pawn.health.hediffSet.hediffs.Contains(pregnancy))
            {
                curStageHrs += 1;
                StayCurrentStageConst(Stage.Pregnant);
            }
            else
            {
                if (pregnancy != null) pregnancy = null;
                GoNextStage(Stage.Recover);
            }
        }

        protected virtual void RecoverAction()
        {
            if (curStageHrs >= currentIntervalHours)
            {
                if (ShouldBeInfertile())
                {
                    GoNextStage(Stage.Infertile);
                }
                else if (!IsBreedingSeason())
                {
                    GoNextStage(Stage.Anestrus);
                }
                else
                {
                    GoNextStage(Stage.Follicular);
                }
            }
            else
            {
                curStageHrs += Configurations.CycleAcceleration;
                StayCurrentStage();
            }
        }

        protected virtual void InfertileAction()
        {
            if (ShouldBeInfertile())
            {
                StayCurrentStageConst(Stage.Infertile);
            }
            else
            {
                bool breedingSeason = IsBreedingSeason();
                GoNextStage(breedingSeason ? Stage.Follicular : Stage.Anestrus, breedingSeason);
            }
        }

        protected virtual void AnestrusAction()
        {
            if (IsBreedingSeason())
            {
                GoFollicularOrBleeding();
            }
            else
            {
                StayCurrentStage();
            }
        }

        protected virtual void ThoughtCumInside(Pawn cummer)
        {
            if (!xxx.is_human(Pawn) || !xxx.is_human(cummer)) return;

            if ((cummer.HasQuirk(QuirkUtility.Quirks.Teratophile) != (Pawn.GetStatValue(StatDefOf.PawnBeauty) >= 0)) ||
                cummer.HasQuirk(QuirkUtility.Quirks.ImpregnationFetish) ||
                cummer.HasQuirk(QuirkUtility.Quirks.Breeder))
            {
                if (cummer.relations.OpinionOf(Pawn) <= -25)
                {
                    cummer.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.HaterCameInsideM, Pawn);
                }
                else
                {
                    cummer.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.CameInsideM, Pawn);
                }
            }

            if (IsDangerDay)
            {
                if (Pawn.HasQuirk(QuirkUtility.Quirks.Breeder) || Pawn.HasQuirk(QuirkUtility.Quirks.ImpregnationFetish))
                {
                    Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.CameInsideFFetish, cummer);
                }
                else if (Pawn.relations.OpinionOf(cummer) <= -5)
                {
                    Pawn.needs.mood.thoughts.memories.RemoveMemoriesOfDefWhereOtherPawnIs(VariousDefOf.CameInsideF, cummer);
                    Pawn.needs.mood.thoughts.memories.RemoveMemoriesOfDefWhereOtherPawnIs(VariousDefOf.HaterCameInsideFEstrus, cummer);
                    Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.HaterCameInsideF, cummer);
                }
                else if (Pawn.IsInEstrus() && Pawn.relations.OpinionOf(cummer) < RJWHookupSettings.MinimumRelationshipToHookup)
                {
                    Pawn.needs.mood.thoughts.memories.RemoveMemoriesOfDefWhereOtherPawnIs(VariousDefOf.CameInsideF, cummer);
                    Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.HaterCameInsideFEstrus, cummer);
                }
                else if (!Pawn.relations.DirectRelationExists(PawnRelationDefOf.Spouse, cummer) && !Pawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, cummer))
                {
                    if (Pawn.health.capacities.GetLevel(xxx.reproduction) < 0.50f) Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.CameInsideFLowFert, cummer);
                    else Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.CameInsideF, cummer);
                }
            }
            else
            {
                if (Pawn.HasQuirk(QuirkUtility.Quirks.Breeder) || Pawn.HasQuirk(QuirkUtility.Quirks.ImpregnationFetish))
                {
                    Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.CameInsideFFetishSafe, cummer);
                }
                else if (Pawn.relations.OpinionOf(cummer) <= -5)
                {
                    Pawn.needs.mood.thoughts.memories.TryGainMemory(VariousDefOf.HaterCameInsideFSafe, cummer);
                }
            }
        }

        protected virtual void TaleCumInside(Pawn cummer)
        {
            // Only make the tale for human-on-human, consentual sex. Otherwise the art just gets too hard to phrase properly
            if (!xxx.is_human(Pawn) || !xxx.is_human(cummer) || Pawn == cummer) return;
            if (Pawn.CurJobDef != xxx.casual_sex && Pawn.CurJobDef != xxx.gettin_loved) return;
            if (!(Pawn.IsColonist || Pawn.IsPrisonerOfColony) && !(cummer.IsColonist || cummer.IsPrisonerOfColony)) return;
            if (!IsDangerDay) return;
            TaleRecorder.RecordTale(VariousDefOf.TaleCameInside, new object[] { cummer, Pawn });
        }

        public void GoNextStage(Stage nextstage, bool calculateHours = true)
        {
            curStageHrs = 0;
            if (calculateHours) currentIntervalHours = PeriodRandomizer(nextstage);
            curStage = nextstage;
        }

        protected virtual void GoOvulatoryStage()
        {
            GoNextStage(Stage.Ovulatory);
        }

        //stage can be interrupted in other reasons
        protected void StayCurrentStage()
        {
        }

        //stage never changes
        protected void StayCurrentStageConst(Stage curstage)
        {
        }

        protected void GoFollicularOrBleeding()
        {
            if (Props.bleedingIntervalDays == 0 || noBleeding)
            {
                GoNextStage(Stage.Follicular);
            }
            else
            {
                GoNextStage(Stage.Bleeding);
                if (crampPain >= 0.05f)
                {
                    AddCrampPain();
                }
            }
        }

        protected int PeriodRandomizer(Stage stage)
        {
            float variabilityFactor = (EggHealth < 1.0f) ? 6.0f : 1.0f;
            // Most cycle lengthening or shortening occurs in the follicular phase, so weight towards that
            switch (stage)
            {
                case Stage.Follicular:
                    return (int)(Props.follicularIntervalDays * 24 * (1 + Rand.Range(-cycleVariability, cycleVariability) * 1.5f * variabilityFactor) / (1 + (cycleSpeed - 1) * 1.5f));
                case Stage.Luteal:
                    return (int)(Props.lutealIntervalDays * 24 * (1 + Rand.Range(-cycleVariability, cycleVariability) * 0.5f * variabilityFactor) / (1 + (cycleSpeed - 1) * 0.5f));
                case Stage.Bleeding:
                    return (int)(Props.bleedingIntervalDays * 24 * (1 + Rand.Range(-cycleVariability, cycleVariability) * 0.5f * variabilityFactor) / (1 + (cycleSpeed - 1) * 0.5f));
                case Stage.Recover:
                    return (int)(Props.recoveryIntervalDays * 24 * Rand.Range(0.95f, 1.05f));
                case Stage.Pregnant:
                    return (int)MenstruationUtility.GestationHours(pregnancy);
                default:
                    return 1;
            }
        }

        protected float InterspeciesImplantFactor(Pawn fertilizer)
        {
            if (fertilizer.def.defName == Pawn.def.defName) return 1.0f;
            else
            {
                if (RJWPregnancySettings.complex_interspecies) return SexUtility.BodySimilarity(Pawn, fertilizer);
                else return RJWPregnancySettings.interspecies_impregnation_modifier;
            }
        }

        protected float PainRandomizer()
        {
            float rand = Rand.Range(0.0f, 1.0f);
            if (rand < 0.01f) return Rand.Range(0.0f, 0.2f);
            else if (rand < 0.2f) return Rand.Range(0.1f, 0.2f);
            else if (rand < 0.8f) return Rand.Range(0.2f, 0.4f);
            else if (rand < 0.95f) return Rand.Range(0.4f, 0.6f);
            else return Rand.Range(0.6f, 1.0f);
        }

        protected Stage RandomStage()
        {
            Stage stage = Rand.ElementByWeight(
                Stage.Follicular, Props.follicularIntervalDays - Props.bleedingIntervalDays,
                Stage.Luteal, Props.lutealIntervalDays,
                Stage.Bleeding, Props.bleedingIntervalDays);

            switch (stage)
            {
                case Stage.Follicular:
                    curStageHrs = Rand.Range(0, (Props.follicularIntervalDays - Props.bleedingIntervalDays) * 24);
                    break;
                case Stage.Luteal:
                    curStageHrs = Rand.Range(0, Props.lutealIntervalDays * 24);
                    break;
                case Stage.Bleeding:
                    curStageHrs = Rand.Range(0, Props.bleedingIntervalDays * 24);
                    break;
            }
            return stage;
        }

        // Searches for a pregnancy unclaimed by any womb and put it in this one
        public void TakeLoosePregnancy()
        {
            if (pregnancy != null) return;

            IEnumerable<Hediff> pregnancies = Pawn.health.hediffSet.hediffs.Where(hediff =>
                hediff is Hediff_BasePregnancy ||
                hediff is Hediff_Pregnant ||
                hediff is Hediff_Labor ||
                hediff is Hediff_LaborPushing);

            pregnancy =
                pregnancies.Except(
                    Pawn.GetMenstruationComps().Select(comp => comp.pregnancy).Where(preg => preg != null)
                    ).FirstOrDefault();
            if (pregnancy != null)
                GoNextStage(Stage.Pregnant);
        }

        public virtual void CopyCycleProperties(HediffComp_Menstruation original)
        {
            cycleSpeed = original.cycleSpeed;
            cycleVariability = original.cycleVariability;
            ovarypower = original.ovarypower;
            crampPain = original.crampPain;
        }

        public int EggsRestoredPerBiosculptor(float yearsWorth)
        {
            return Math.Max(1, (int)((float)RaceCyclesPerYear() * yearsWorth));
        }

        public void RestoreEggs(float yearsWorth)
        {
            ovarypower += EggsRestoredPerBiosculptor(yearsWorth);
        }

        public class Egg : IExposable
        {
            public bool fertilized;
            public int lifespanhrs;
            public Pawn fertilizer;
            public int position;
            public int fertstage = 0;

            public Egg()
            {
                fertilized = false;
                lifespanhrs = (int)(96 * Configurations.EggLifespanMultiplier);
                fertilizer = null;
                position = 0;
            }

            public Egg(int lifespanhrs)
            {
                fertilized = false;
                this.lifespanhrs = (int)(lifespanhrs * Configurations.EggLifespanMultiplier);
                fertilizer = null;
                position = 0;
            }

            public void ExposeData()
            {
                Scribe_References.Look(ref fertilizer, "fertilizer", true);
                Scribe_Values.Look(ref fertilized, "fertilized", fertilized, true);
                Scribe_Values.Look(ref lifespanhrs, "lifespanhrs", lifespanhrs, true);
                Scribe_Values.Look(ref position, "position", position, true);
                Scribe_Values.Look(ref fertstage, "fertstage", fertstage, true);
            }
        }


    }

    public class HediffComp_Anus : HediffComp
    {
        protected float? originanussize;

        public float OriginAnusSize
        {
            get
            {
                if (originanussize == null)
                {
                    originanussize = parent.Severity;
                }
                return originanussize ?? 0.1f;
            }
        }

        public override void CompExposeData()
        {
            base.CompExposeData();
            Scribe_Values.Look(ref originanussize, "originanussize", originanussize, true);
        }

        public override void CompPostTick(ref float severityAdjustment)
        {
        }
    }
}