using System;
using System.Collections.Generic;
using Eremite.Buildings;
using Eremite.Model;
using Eremite.Model.Meta;
using Eremite.Services;
using HarmonyLib;

// Patch maxSupPoints in PlatoonSupplyModule
// Patch Operational Authority point gain

namespace AgainstTheStorm {
    [HarmonyPatch]
    public class Patches {
        static Dictionary<string, float> baseValues = new Dictionary<string, float>();

        [HarmonyPrefix]
        [HarmonyPatch(typeof(BonusEmbarkRangeMetaRewardModel), "OnConsume")]
        static void Test(BonusEmbarkRangeMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(BonusFarmAreaMetaRewardModel), "OnConsume")]
        static void Test(BonusFarmAreaMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(ConstructionSpeedMetaRewardModel), "OnConsume")]
        static void Test(ConstructionSpeedMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(CornerstonesRerollsMetaRewardModel), "OnConsume")]
        static void Test(CornerstonesRerollsMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(CurrencyMultiplayerMetaRewardModel), "OnConsume")]
        static void Test(CurrencyMultiplayerMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(EmbarkGoodsAmountMetaRewardModel), "OnConsume")]
        static void Test(EmbarkGoodsAmountMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(FarmingRateMetaRewardModel), "OnConsume")]
        static void Test(FarmingRateMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(FuelRateMetaRewardModel), "OnConsume")]
        static void Test(FuelRateMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GlobalBuildingStorageMetaRewardModel), "OnConsume")]
        static void Test(GlobalBuildingStorageMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GlobalCapacityMetaRewardModel), "OnConsume")]
        static void Test(GlobalCapacityMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GlobalExtraProductionChanceMetaRewardModel), "OnConsume")]
        static void Test(GlobalExtraProductionChanceMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GlobalProductionSpeedMetaRewardModel), "OnConsume")]
        static void Test(GlobalProductionSpeedMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GracePeriodMetaRewardModel), "OnConsume")]
        static void Test(GracePeriodMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(GrassAmountMetaRewardModel), "OnConsume")]
        static void Test(GrassAmountMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(HearthSacraficeTimeRateMetaRewardModel), "OnConsume")]
        static void Test(HearthSacraficeTimeRateMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(NewcommersGoodsRateMetaRewardModel), "OnConsume")]
        static void Test(NewcommersGoodsRateMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(PreparationPointsMetaRewardModel), "OnConsume")]
        // static void Test(PreparationPointsMetaRewardModel __instance) {
        //     DoPatch(__instance);
        // }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(RawDepositsChargesMetaRewardModel), "OnConsume")]
        static void Test(RawDepositsChargesMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(RelicsWorkingSpeedMetaRewardModel), "OnConsume")]
        static void Test(RelicsWorkingSpeedMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(ReputationPenaltyRateMetaRewardModel), "OnConsume")]
        static void Test(ReputationPenaltyRateMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(ReputationRewardPicksMetaRewardModel), "OnConsume")]
        static void Test(ReputationRewardPicksMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(SeasonRewardsAmountMetaRewardModel), "OnConsume")]
        static void Test(SeasonRewardsAmountMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TownsVisionRangeMetaRewardModel), "OnConsume")]
        static void Test(TownsVisionRangeMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TraderIntervalMetaRewardModel), "OnConsume")]
        static void Test(TraderIntervalMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TraderMerchAmountMetaRewardModel), "OnConsume")]
        static void Test(TraderMerchAmountMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TraderMerchandisePriceReductionMetaRewardModel), "OnConsume")]
        static void Test(TraderMerchandisePriceReductionMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TradeRoutesLimitMetaReward), "OnConsume")]
        static void Test(TradeRoutesLimitMetaReward __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TraderSellPriceMetaRewardModel), "OnConsume")]
        static void Test(TraderSellPriceMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(VillagersSpeedMetaRewardModel), "OnConsume")]
        static void Test(VillagersSpeedMetaRewardModel __instance) {
            DoPatch(__instance);
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(ProductionCalculator), nameof(ProductionCalculator.GetProductionMultiplier))]
        static void PatchProductionCalculator(ref int __result) {
            // Console.WriteLine("ProdMulti {0}", __result);
            __result *= Main.ProductionMultiplier.Value;
        }

        // There seems to be a lot of good shit in effetsService!!
        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetRawDepositsChargesBonus))]
        static void PatchEffectsService(ref int __result) {
            __result *= Main.DepositChargesMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetActorSpeed))]
        static void PatchEffectsService2(ref float __result) {
            __result *= Main.VillagerSpeedMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetBuildingProductionRate))]
        static void PatchEffectsService3(ref float __result) {
            __result *= Main.ProductionSpeedMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersIntervalRate))]
        static void PatchEffectsService4(ref float __result) {
            __result *= Main.NewcomverRateMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetVillagerCapacity))]
        static void PatchEffectsService5(ref int __result) {
            __result *= Main.VillagerCapacityMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTraderIntervalRate))]
        static void PatchEffectsService6(ref float __result) {
            __result *= Main.TraderRateMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTraderMerchsAmount))]
        static void PatchEffectsService7(ref int __result) {
            __result *= Main.TraderMerchMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHearthRange))]
        static void PatchEffectsService8(ref float __result) {
            __result *= Main.HearthRangeMultiplier.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHouseCapacity), typeof(HouseModel))]
        static void PatchEffectsService9(ref int __result) {
            __result = (int)(Main.HouseCapacityMultiplier.Value * __result);
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHouseCapacity), typeof(House))]
        static void PatchEffectsService9_2(ref int __result) {
            __result = (int)(Main.HouseCapacityMultiplier.Value * __result);
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersBonus))]
        static void PatchEffectsService10(ref int __result) {
            __result = (int)(Main.NewcomerBonusMultiplier.Value * __result);
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersRaceBonus))]
        static void PatchEffectsService11(ref int __result) {
            __result += Main.AdditionalNewcomerBonus.Value;
        }

        [HarmonyPostfix]
        [HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTradeRoutesSpeed))]
        static void PatchEffectsService12(ref float __result) {
            __result += Main.TradeRouteSpeedMultiplier.Value;
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(TimeScaleService), "SetScale")]
        static void PatchGameSpeeds(ref float scale) {
            scale *= Main.GameSpeedMultiplier.Value;
        }

        [HarmonyPrefix]
        [HarmonyPatch(typeof(MetaEconomyService), nameof(MetaEconomyService.Add))]
        static void PatchMetaCurrencyGain(ref MetaCurrency currency) {
            currency.amount = (int)(currency.amount * Main.MetaCurrencyMultiplier.Value);
        }

        static void DoPatch(BasePercentageMetaReward model) {
            string upgName = model.displayName.ToString();
            if (!baseValues.ContainsKey(upgName)) {
                Console.WriteLine("Base value does not exist yet for {0} (class: {1}), adding", upgName,
                    model.GetType().Name);
                baseValues.Add(upgName, model.amount);
            }

            if (Math.Abs(baseValues[upgName] - model.amount) < 0.01f) {
                float newValue = baseValues[upgName] * 64;
                Console.WriteLine("Base value is different for {0}, updating from {1} to {2}", upgName,
                    baseValues[upgName],
                    newValue);
                baseValues[upgName] = newValue;
            }
            else {
                Console.WriteLine("Base value is the same for {0}, skipping {1}", upgName, baseValues[upgName]);
            }
        }

        static void DoPatch(BaseFlatMetaReward model) {
            string upgName = model.displayName.ToString();
            if (!baseValues.ContainsKey(upgName)) {
                Console.WriteLine("Base value does not exist yet for {0} (class: {1}), adding", upgName,
                    model.GetType().Name);
                baseValues.Add(upgName, model.amount);
            }

            if (Math.Abs(baseValues[upgName] - model.amount) < 0.01f) {
                float newValue = baseValues[upgName] * 64;
                Console.WriteLine("Base value is different for {0}, updating from {1} to {2}", upgName,
                    baseValues[upgName],
                    newValue);
                baseValues[upgName] = newValue;
            }
            else {
                Console.WriteLine("Base value is the same for {0}, skipping {1}", upgName, baseValues[upgName]);
            }
        }

        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(TacAidPointsController), "AddTP")]
        // static void TpMultiplier(ref float val) {
        //     if (val == 0) {
        //         return;
        //     }
        //
        //     float multiplier = Main.TPMultiplier.Value;
        //     // Console.WriteLine("Multiplying TP {0} by {1}", val, multiplier);
        //     val *= multiplier;
        // }
        //
        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(MapZoneFactory), "MakeRefitZone")]
        // static void SupplyAoeMultiplier(ref eSides side, ref Vector3 position, ref float size) {
        //     float multiplier = Main.SupplyAOEMultiplier.Value;
        //     Console.WriteLine("Multiplying supply aoe {0} by {1}", size, multiplier);
        //     size *= multiplier;
        // }
        //
        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(PlatoonHQVisuals), "Start")]
        // static void HqAoeMultiplier(PlatoonHQVisuals __instance) {
        //     Console.WriteLine("Patching HQ radius - base range {0}", baseHqValue);
        //     if (baseHqValue == 0) {
        //         baseHqValue = __instance.platoon.parameters.HQRadius;
        //         Console.WriteLine("Base range is 0, assigning new: {0}", baseHqValue);
        //     }
        //
        //     __instance.platoon.parameters.HQRadius = baseHqValue * Main.HQAOEMultiplier.Value;
        //     Console.WriteLine("HQ radius patched to: {0}", __instance.platoon.parameters.HQRadius);
        // }
        //
        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(PlatoonSupplyModule), "Start")]
        // static void SupplyAoeMultiplier(PlatoonSupplyModule __instance) {
        //     Console.WriteLine("Patching supply amount - base amount {0}", baseSupplyValue);
        //     if (baseSupplyValue == 0) {
        //         baseSupplyValue = __instance.platoon.parameters.supplyPointsPerUnit;
        //         Console.WriteLine("Base amount is 0, assigning new: {0}", baseSupplyValue);
        //     }
        //
        //     __instance.platoon.parameters.supplyPointsPerUnit =
        //         (int)(baseSupplyValue * Main.SupplyAmountMultiplier.Value);
        //     Console.WriteLine("Supply amount patched to: {0}", __instance.platoon.parameters.supplyPointsPerUnit);
        // }
        //
        // [HarmonyPostfix]
        // [HarmonyPatch(typeof(WeaponAttackBase), "GetReloadInterval")]
        // static void FireRateMultiplier(ref float __result) {
        //     Console.WriteLine("Patching fire rate");
        //
        //     __result *= Main.FireRateMultiplier.Value;
        //     Console.WriteLine("Fire rate patched to: {0}", __result);
        // }
        //
        // [HarmonyPostfix]
        // [HarmonyPatch(typeof(WeaponAttackBase), "GetAimInterval")]
        // static void AimingIntervalMultiplier(ref float __result) {
        //     Console.WriteLine("Patching aim interval - base amount {0}", baseSupplyValue);
        //
        //     __result *= Main.AimIntervalMultiplier.Value;
        //     Console.WriteLine("Aim interval patched to: {0}", __result);
        // }
        //
        // [HarmonyPrefix]
        // [HarmonyPatch(typeof(TimerManager), "GetPersistentTimer")]
        // static void Transpiler(ref float interval, ref string hint) {
        //     if (hint == "burst") {
        //         Console.WriteLine("Patching burst interval from: {0}", interval);
        //         interval *= Main.FireRateMultiplier.Value;
        //         Console.WriteLine("Burst interval patched to: {0}", interval);
        //     }
        // }
        //
        // [HarmonyPostfix]
        // [HarmonyPatch(typeof(RefitZone), "OnRefitStep")]
        // static void SupplyRateMultiplier(ref float hpVal, ref float ammoVal) {
        //     Console.WriteLine("Patching refit step from: {0} {1}", hpVal, ammoVal);
        //     hpVal *= Main.SupplyRateMultiplier.Value;
        //     ammoVal *= Main.SupplyRateMultiplier.Value;
        //     Console.WriteLine("Patching refit step to: {0} {1}", hpVal, ammoVal);
        // }
        //
        // // [HarmonyPatch(typeof(AdvancedRulesData), "Validate")]
        // // static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) {
        // //     var codes = new List<CodeInstruction>(instructions);
        // //
        // //     foreach (var code in codes) {
        // //         if (code.opcode == OpCodes.Ldc_R4) {
        // //             Console.WriteLine("Changing " + code);
        // //             code.operand = (float)code.operand * 2;
        // //             Console.WriteLine("Changed " + code);
        // //         }
        // //     }
        // //
        // //     return codes.AsEnumerable();
        // // }
        //
        // // [HarmonyPatch(typeof(AdvancedRulesData), "IsWithinLimits")]
        // // static IEnumerable<CodeInstruction> Transpiler2(IEnumerable<CodeInstruction> instructions) {
        // //     var codes = new List<CodeInstruction>(instructions);
        // //
        // //     foreach (var code in codes) {
        // //         if (code.opcode == OpCodes.Ldc_R4) {
        // //             Console.WriteLine("Changing " + code);
        // //             code.operand = (float)code.operand * 2;
        // //             Console.WriteLine("Changed " + code);
        // //         }
        // //     }
        // //
        // //     return codes.AsEnumerable();
        // // }
        //
        // // private static float baseAccuracy;
        // //
        // // [HarmonyPostfix]
        // // [HarmonyPatch(typeof(SkirmishAdvancedRules), "Update")]
        // // static void AccuracyPatch(SkirmishAdvancedRules __instance) {
        // //     var accMod = Traverse.Create(__instance).Field("currentARD").Field("accuracyModifier");
        // //     if (baseAccuracy == 0) {
        // //         baseAccuracy = (float)accMod.GetValue();
        // //         Console.WriteLine("Base accuracy set to {0}", baseAccuracy);
        // //     }
        // //
        // //     accMod.SetValue(baseAccuracy * 4f);
        // //     Console.WriteLine("Accuracy now: {0}", accMod.GetValue());
        // // }
    }
}
