using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HarmonyLib;
using RimWorld;
using UnityEngine;
using Verse;
using Verse.AI.Group;

namespace Implants.Biotech
{
    #region Command Range

    [HarmonyPatchCategory("Biotech")]
    class BiotechMechanitorPatches
    {
        [HarmonyPatch(typeof(Pawn_MechanitorTracker))]
        [HarmonyPatch(nameof(Pawn_MechanitorTracker.CanCommandTo))]
        class
            Pawn_MechanitorTracker_CanCommandTo_Patch //increases the mechanitor's range by MechRemoteControlDistanceOffset
        {
            /// <summary>
            /// pushed always commandable check to front to reduct compute.
            /// TODO perhaps need a custom patch order to make sure this logic always works.
            /// </summary>
            /// <param name="target">target mech to command</param>
            /// <param name="__instance">should be mechanitor, but not always the mechanitor for example like Dead man switch ctrl mechs </param>
            /// <param name="__result">Commandable result from original code.</param>
            [HarmonyPostfix]
            public static void CanCommandToPostfix(LocalTargetInfo target, Pawn_MechanitorTracker __instance,
                ref bool __result)
            {
                if (__result)
                    return;
                float SignalBoosterRange =
                    __instance.Pawn?.GetStatValue(StatDef.Named("MechRemoteControlDistanceOffset")) ?? 0f;
                __result = target.Cell.InBounds(__instance.Pawn.MapHeld) &&
                           (float)__instance.Pawn.Position.DistanceToSquared(target.Cell) <
                           (24.9f + SignalBoosterRange) *
                           (24.9f +
                            SignalBoosterRange); //last line should mean that if something else makes it true, then it is(?)
            }
        }

        [HarmonyPatch(typeof(Pawn_MechanitorTracker))]
        [HarmonyPatch(nameof(Pawn_MechanitorTracker.DrawCommandRadius))]
        class
            Pawn_MechanitorTracker_DrawCommandRadius_Patch //increases the displayed mechanitor range by MechRemoteControlDistanceOffset
        {
            /// <summary>
            /// Skip original draw radius using a prefix.
            /// TODO may need specify fixed patch order to make sure this works.
            /// </summary>
            /// <returns>return false to skip original draw.</returns>
            [HarmonyPrefix]
            static bool DrawCommandRadiusPrefix()
            {
                return false;
            }

            /// <summary>
            /// Postfix the draw radius by apply our extended radius on top.
            /// </summary>
            /// <param name="__instance"></param>
            [HarmonyPostfix]
            public static void DrawCommandRadiusPostfix(Pawn_MechanitorTracker __instance)
            {
                if (__instance.Pawn.Spawned && __instance.AnySelectedDraftedMechs)
                {
                    //GenDraw.DrawRadiusRing(___pawn.Position, 24.9f + (3f*___pawn.health?.hediffSet?.GetFirstHediffOfDef(HediffDef.Named("SignalBoosterImplant"))?.Severity ?? 0f), Color.white, (IntVec3 c) => __instance.CanCommandTo(c));
                    if (!ModsConfig.IsActive("swwu.MechanitorCommandRange") &&
                        !ModsConfig.IsActive(
                            "Neronix17.TweaksGalore")) //for tweaks galore, it'd be better to try to find the setting specifically, with an inverted result and a null check true
                    {
                        IntVec3 position = __instance.Pawn.Position;
                        float radius = 24.9f +
                                       (__instance.Pawn?.GetStatValue(
                                           StatDef.Named("MechRemoteControlDistanceOffset")) ?? 0f);
                        //Make our command circle yellow. And make sure this postfix implemented draw follows vanilla impl.
                        GenDraw.DrawRadiusRing(position, radius, Color.yellow,
                            (IntVec3 c) => __instance.CanCommandTo((LocalTargetInfo)c));
                    }
                }
            }
        }
    }

    #endregion

    #region Resurrect

    public class CompProperties_MechanitorResurrectMech : CompProperties_AbilityEffect
    {
        public CompProperties_MechanitorResurrectMech()
        {
            this.compClass = typeof(CompAbilityEffect_MechanitorResurrectMech);
        }

        public int maxCorpseAgeTicks = int.MaxValue;

        public EffecterDef appliedEffecterDef;

        public EffecterDef resolveEffecterDef;

        //public EffecterDef centerEffecterDef;
    }

    public class CompAbilityEffect_MechanitorResurrectMech : CompAbilityEffect
    {
        public new CompProperties_MechanitorResurrectMech Props
        {
            get { return (CompProperties_MechanitorResurrectMech)this.props; }
        }

        public override bool CanApplyOn(LocalTargetInfo target, LocalTargetInfo dest)
        {
            Corpse corpse;
            bool bandwidthCheck = (target.Thing as Corpse).InnerPawn.GetStatValue(StatDef.Named("BandwidthCost")) <=
                                  this.parent.pawn.mechanitor.TotalBandwidth -
                                  this.parent.pawn.mechanitor.UsedBandwidth;
            bool canApplyOnCheck = (base.CanApplyOn(target, dest) && target.HasThing &&
                                    (corpse = target.Thing as Corpse) != null && this.CanResurrect(corpse) &&
                                    bandwidthCheck);
            //Log.Message("CanApplyOn check: " + canApplyOnCheck);


            if ((target.Thing as Corpse).InnerPawn.Faction != this.parent.pawn.Faction)
            {
                Messages.Message("Can only resurrect allied mechs", (target.Thing as Pawn),
                    MessageTypeDefOf.NegativeEvent);
            }
            else if ((target.Thing as Corpse).timeOfDeath <=
                     Find.TickManager.TicksGame - this.Props.maxCorpseAgeTicks)
            {
                Messages.Message("Target has been dead too long", (target.Thing as Pawn),
                    MessageTypeDefOf.NegativeEvent);
            }
            else if (!bandwidthCheck)
            {
                Messages.Message("Insufficient bandwidth", (target.Thing as Pawn), MessageTypeDefOf.NegativeEvent);
            }


            return canApplyOnCheck;
        }


        private bool CanResurrect(Corpse corpse)
        {
            //return corpse.InnerPawn.RaceProps.IsMechanoid && corpse.InnerPawn.RaceProps.mechWeightClass < MechWeightClass.UltraHeavy && corpse.InnerPawn.Faction == this.parent.pawn.Faction && (corpse.InnerPawn.kindDef.abilities == null || !corpse.InnerPawn.kindDef.abilities.Contains(AbilityDefOf.ResurrectionMech)) && corpse.timeOfDeath >= Find.TickManager.TicksGame - this.Props.maxCorpseAgeTicks;
            return corpse.InnerPawn.RaceProps.IsMechanoid && corpse.InnerPawn.Faction == this.parent.pawn.Faction &&
                   (corpse.InnerPawn.kindDef.abilities == null ||
                    !corpse.InnerPawn.kindDef.abilities.Contains(AbilityDefOf.ResurrectionMech)) &&
                   corpse.timeOfDeath >= Find.TickManager.TicksGame - this.Props.maxCorpseAgeTicks;
        }


        public override void Apply(LocalTargetInfo target, LocalTargetInfo dest)
        {
            //Log.Message("Apply called");
            base.Apply(target, dest);
            Corpse corpse = (Corpse)target.Thing;
            if (!this.CanResurrect(corpse))
            {
                return;
            }

            Pawn innerPawn = corpse.InnerPawn;
            ResurrectionUtility.TryResurrect(innerPawn, null);
            if (this.Props.appliedEffecterDef != null)
            {
                Effecter effecter = this.Props.appliedEffecterDef.SpawnAttached(innerPawn, innerPawn.MapHeld, 1f);
                effecter.Trigger(innerPawn, innerPawn, -1);
                effecter.Cleanup();
                this.parent.pawn.relations.AddDirectRelation(PawnRelationDefOf.Overseer,
                    innerPawn); //if resurrection successful, immediately takes control of resurrected mech.
            }

            innerPawn.stances.stagger.StaggerFor(60, 0.17f);
        }

        public override bool GizmoDisabled(out string reason)
        {
            reason = null;
            return false;
        }

        public override IEnumerable<Mote> CustomWarmupMotes(LocalTargetInfo target)
        {
            foreach (LocalTargetInfo localTargetInfo in this.parent.GetAffectedTargets(target))
            {
                Thing thing = localTargetInfo.Thing;
                yield return MoteMaker.MakeAttachedOverlay(thing, ThingDefOf.Mote_MechResurrectWarmupOnTarget,
                    Vector3.zero, 1f, -1f);
            }

            yield break;
        }

        public override void PostApplied(List<LocalTargetInfo> targets, Map map)
        {
            //Log.Message("PostApplied called");
            Vector3 vector = Vector3.zero;
            foreach (LocalTargetInfo localTargetInfo in targets)
            {
                vector += localTargetInfo.Cell.ToVector3Shifted();
            }

            vector /= (float)targets.Count<LocalTargetInfo>();
            IntVec3 intVec = vector.ToIntVec3();
            this.Props.resolveEffecterDef.Spawn(intVec, map, 1f).EffectTick(new TargetInfo(intVec, map, false),
                new TargetInfo(intVec, map, false));
        }
    }

    #endregion

    #region Remote Dominate

    public class CompProperties_MechanitorDominateMech : CompProperties_AbilityEffect
    {
        public CompProperties_MechanitorDominateMech()
        {
            this.compClass = typeof(CompAbilityEffect_MechanitorDominateMech);
        }
    }

    public class CompAbilityEffect_MechanitorDominateMech : CompAbilityEffect
    {
        public new CompProperties_MechanitorDominateMech Props
        {
            get { return (CompProperties_MechanitorDominateMech)this.props; }
        }

        public override bool CanApplyOn(LocalTargetInfo target, LocalTargetInfo dest)
        {
            Pawn pawn;

            bool bandwidthCheck = (target.Thing as Pawn).GetStatValue(StatDef.Named("BandwidthCost")) <=
                                  this.parent.pawn.mechanitor.TotalBandwidth -
                                  this.parent.pawn.mechanitor.UsedBandwidth;
            bool notTempMech = target.Thing.TryGetComp<CompMechPowerCell>() == null;
            bool canApplyOnCheck = (base.CanApplyOn(target, dest) && target.HasThing &&
                                    (pawn = target.Thing as Pawn) != null && bandwidthCheck &&
                                    this.CanDominate(pawn) && notTempMech);


            if (!notTempMech)
            {
                Messages.Message("Cannot target temporary mech", (target.Thing as Pawn),
                    MessageTypeDefOf.NegativeEvent);
            }
            else if ((target.Thing as Pawn).RaceProps.mechWeightClass >= MechWeightClass.UltraHeavy)
            {
                Messages.Message("Cannot target superheavy mech", (target.Thing as Pawn),
                    MessageTypeDefOf.NegativeEvent);
            }
            else if (!bandwidthCheck)
            {
                Messages.Message("Insufficient bandwidth", (target.Thing as Pawn), MessageTypeDefOf.NegativeEvent);
            }

            return canApplyOnCheck;
        }


        private bool CanDominate(Pawn pawn)
        {
            return pawn.RaceProps.IsMechanoid && pawn.RaceProps.mechWeightClass < MechWeightClass.UltraHeavy &&
                   (pawn.kindDef.abilities == null ||
                    !pawn.kindDef.abilities.Contains(AbilityDefOf.ResurrectionMech));
        }


        public override void Apply(LocalTargetInfo target, LocalTargetInfo dest)
        {
            //Log.Message("Apply called");
            base.Apply(target, dest);
            Pawn pawn = (Pawn)target;
            if (!this.CanDominate(pawn))
            {
                return;
            }


            pawn.SetFaction(this.parent.pawn.Faction); //convert pawn

            this.parent.pawn.relations.AddDirectRelation(PawnRelationDefOf.Overseer, pawn);
            pawn.stances.stagger.StaggerFor(60, 0.17f);
        }

        public override bool GizmoDisabled(out string reason)
        {
            reason = null;
            return false;
        }

        //public override IEnumerable<Mote> CustomWarmupMotes(LocalTargetInfo target)
        //{
        //    foreach (LocalTargetInfo localTargetInfo in this.parent.GetAffectedTargets(target))
        //    {
        //        Thing thing = localTargetInfo.Thing;
        //        yield return MoteMaker.MakeAttachedOverlay(thing, ThingDefOf.Mote_MechResurrectWarmupOnTarget, Vector3.zero, 1f, -1f);
        //    }
        //    IEnumerator<LocalTargetInfo> enumerator = null;
        //    yield break;
        //    yield break;
        //}

        public override void PostApplied(List<LocalTargetInfo> targets, Map map)
        {
            //Log.Message("PostApplied called");
            //Vector3 vector = Vector3.zero;
            //foreach (LocalTargetInfo localTargetInfo in targets)
            //{
            //    vector += localTargetInfo.Cell.ToVector3Shifted();
            //}
            //vector /= (float)targets.Count<LocalTargetInfo>();
            //IntVec3 intVec = vector.ToIntVec3();
            //this.Props.resolveEffecterDef.Spawn(intVec, map, 1f).EffectTick(new TargetInfo(intVec, map, false), new TargetInfo(intVec, map, false));
        }
    }

    #endregion

    #region Mech carrier

    public class CompProperties_MechanitorMechCarrier : CompProperties_AbilityEffect
    {
        public CompProperties_MechanitorMechCarrier()
        {
            this.compClass = typeof(CompAbilityEffect_MechanitorMechCarrier);
        }

        public PawnKindDef spawnPawnKind;
        public int cooldownTicks = 900;
        public int maxPawnsToSpawn = 2;
        public EffecterDef spawnEffecter;
        public EffecterDef spawnedMechEffecter;
        public bool attachSpawnedEffecter;
        public bool attachSpawnedMechEffecter;
    }

    public class CompAbilityEffect_MechanitorMechCarrier : CompAbilityEffect
    {
        public new CompProperties_MechanitorMechCarrier Props
        {
            get { return (CompProperties_MechanitorMechCarrier)this.props; }
        }

        public override void CompTick()
        {
            base.CompTick();
            //if (Find.Selector.IsSelected(parent.pawn) && (int)Find.TickManager.CurTimeSpeed != 0 && Find.TickManager.TicksGame % (int)Find.TickManager.CurTimeSpeed == 0)//if the mechanitor is selected, and once erry 60/1 irl seconds
            //{
            //    for (int i = 0; i < spawnedPawns.Count; i++)
            //    {
            //        if (!spawnedPawns[i].Dead)
            //        {
            //            GenDraw.DrawLineBetween(this.parent.pawn.TrueCenter(), spawnedPawns[i].TrueCenter());
            //        }
            //    }
            //}
        }

        public override void Apply(LocalTargetInfo target, LocalTargetInfo dest)
        {
            base.Apply(target, dest);
            TrySpawnPawns();
        }

        public int maxspawn()
        {
            //Log.Message("RemainingCharges: " + parent.RemainingCharges+1);
            int max = parent.RemainingCharges +
                      1; //requires +1 to account for the charge that's automatically used upon ability activation, prior to this.
            if (max > 2)
            {
                return 2;
            }
            else
            {
                return max;
            }
        }

        public void TrySpawnPawns()
        {
            int maxCanSpawn = maxspawn();
            //Log.Message("max spawns: "+ maxCanSpawn);
            if (maxCanSpawn <= 0)
            {
                return;
            }

            PawnGenerationRequest pawnGenerationRequest = new PawnGenerationRequest(this.Props.spawnPawnKind,
                this.parent.pawn.Faction, PawnGenerationContext.NonPlayer, -1, true, false, false, true, false, 1f,
                false, true, false, true, true, false, false, false, false, 0f, 0f, null, 1f, null, null, null,
                null, null, null, null, null, null, null, null, null, false, false, false, false, null, null, null,
                null, null, 0f, DevelopmentalStage.Newborn, null, null, null, false, false, false, -1, 0, false);
            Pawn pawn;
            Lord lord = (((pawn = this.parent.pawn as Pawn) != null) ? pawn.GetLord() : null);
            for (int i = 0; i < maxCanSpawn; i++)
            {
                Pawn pawn2 = PawnGenerator.GeneratePawn(pawnGenerationRequest);
                GenSpawn.Spawn(pawn2, this.parent.pawn.Position, this.parent.pawn.Map, WipeMode.Vanish);
                this.spawnedPawns.Add(pawn2);
                if (lord != null)
                {
                    lord.AddPawn(pawn2);
                }

                if (this.Props.spawnedMechEffecter != null)
                {
                    Effecter effecter = new Effecter(this.Props.spawnedMechEffecter);
                    effecter.Trigger(
                        this.Props.attachSpawnedMechEffecter
                            ? pawn2
                            : new TargetInfo(pawn2.Position, pawn2.Map, false), TargetInfo.Invalid, -1);
                    effecter.Cleanup();
                }
            }

            this.cooldownTicksRemaining = this.Props.cooldownTicks;
            if (this.Props.spawnEffecter != null)
            {
                Effecter effecter2 = new Effecter(this.Props.spawnEffecter);
                effecter2.Trigger(
                    this.Props.attachSpawnedEffecter
                        ? this.parent.pawn
                        : new TargetInfo(this.parent.pawn.Position, this.parent.pawn.Map, false),
                    TargetInfo.Invalid, -1);
                effecter2.Cleanup();
            }

            if (maxCanSpawn == 2) //subtract an extra charge, as we're summoning 2
            {
                parent.RemainingCharges--;
            }
        }

        public List<Pawn> GetSpawnedPawns()
        {
            return spawnedPawns;
        }

        private int cooldownTicksRemaining;
        private List<Pawn> spawnedPawns = new List<Pawn>();
        public SoundDef soundReload;
    }

    public class HediffCompProperties_KillSpawnedPawns : HediffCompProperties
    {
        public AbilityDef abilityDef;

        public HediffCompProperties_KillSpawnedPawns()
        {
            compClass = typeof(HediffComp_KillSpawnedPawns);
        }
    }

    public class HediffComp_KillSpawnedPawns : HediffComp
    {
        public HediffCompProperties_KillSpawnedPawns Props => (HediffCompProperties_KillSpawnedPawns)props;

        public override void Notify_PawnKilled()
        {
            foreach (Pawn i in base.Pawn.abilities.GetAbility(Props.abilityDef)
                         .CompOfType<CompAbilityEffect_MechanitorMechCarrier>().GetSpawnedPawns())
            {
                if (!i.Dead)
                {
                    i.Kill(null, null);
                }
            }
        }
    }

    #endregion

    #region Call a cluster

    public class CompProperties_AbilityMechCluster : CompProperties_AbilityEffect
    {
        public CompProperties_AbilityMechCluster()
        {
            this.compClass = typeof(CompAbilityEffect_MechCluster);
        }

        public float displayRadius;
    }

    public class CompAbilityEffect_MechCluster : CompAbilityEffect
    {
        public new CompProperties_AbilityMechCluster Props
        {
            get { return (CompProperties_AbilityMechCluster)this.props; }
        }

        public bool ShouldHaveInspectString
        {
            get { return ModsConfig.BiotechActive && this.parent.pawn.RaceProps.IsMechanoid; }
        }

        public override void Apply(LocalTargetInfo target, LocalTargetInfo dest)
        {
            base.Apply(target, dest);
            if (Faction.OfMechanoids == null)
            {
                Messages.Message("MessageNoFactionForVerbMechCluster".Translate(), this.parent.pawn,
                    MessageTypeDefOf.RejectInput, null, false);
            }
            else
            {
                MechClusterUtility.SpawnCluster(target.Cell, this.parent.pawn.MapHeld,
                    MechClusterGenerator.GenerateClusterSketch(2500f, this.parent.pawn.MapHeld, true, true), true,
                    false, null);
            }
        }

        public override void PostApplied(List<LocalTargetInfo> targets, Map map)
        {
            base.PostApplied(targets, map);
            if (this.parent.def.defName ==
                "MechhiveSatelliteUplink") //add field for cooldownFactorStat. Change this if statement to if it's not null. change the contents of getstatvalue on the next line to that field.
            {
                this.parent.StartCooldown(Mathf.RoundToInt(this.parent.def.cooldownTicksRange.RandomInRange *
                    this.parent.pawn?.GetStatValue(StatDef.Named("MechhiveSatelliteUplinkCooldownFactor")) ?? 1f));
            }
        }

        public override void DrawEffectPreview(LocalTargetInfo target)
        {
            GenDraw.DrawRadiusRing(target.Cell, this.Props.displayRadius);
        }

        public override string CompInspectStringExtra()
        {
            if (!this.ShouldHaveInspectString)
            {
                return null;
            }

            if (this.parent.CanCast)
            {
                return "AbilityMechSmokepopCharged".Translate();
            }

            return "AbilityMechSmokepopRecharging".Translate(
                this.parent.CooldownTicksRemaining.ToStringTicksToPeriod(true, false, true, true, false));
        }
    }

    #endregion
}