import { CorpMaterialName, CorpResearchName, CorpStateName } from "@nsdefs";
import { CityName, CorpEmployeeJob, IndustryType } from "@enums";
import { constructorsForReviver, Generic_toJSON, Generic_fromJSON, IReviverValue } from "../utils/JSONReviver";
import { IndustryResearchTrees, IndustriesData } from "./data/IndustryData";
import * as corpConstants from "./data/Constants";
import { getRandomIntInclusive } from "../utils/helpers/getRandomIntInclusive";
import { calculateEffectWithFactors } from "../utils/calculateEffectWithFactors";
import { OfficeSpace } from "./OfficeSpace";
import { Product } from "./Product";
import { dialogBoxCreate } from "../ui/React/DialogBox";
import { MaterialInfo } from "./MaterialInfo";
import { Warehouse } from "./Warehouse";
import { Corporation } from "./Corporation";
import { JSONMap, JSONSet } from "../Types/Jsonable";
import { PartialRecord, getRecordEntries, getRecordKeys, getRecordValues } from "../Types/Record";
import { Material } from "./Material";
import { getKeyList } from "../utils/helpers/getKeyList";
import { calculateMarkupMultiplier } from "./helpers";
import { exceptionAlert } from "../utils/helpers/exceptionAlert";
import { throwIfReachable } from "../utils/helpers/throwIfReachable";
import { assertObject } from "../utils/TypeAssertion";

interface DivisionParams {
  name: string;
  corp: Corporation;
  industry: IndustryType;
}

export class Division {
  name = "DefaultDivisionName";
  industry = IndustryType.Agriculture;
  researchPoints = 0;
  researched = new JSONSet<CorpResearchName>();
  requiredMaterials: PartialRecord<CorpMaterialName, number> = {};

  // Not included in save file. Just used for tracking whether research tree has been updated since game load.
  treeInitialized = false;

  /** An array of the name of materials being produced */
  producedMaterials: CorpMaterialName[] = [];

  products = new JSONMap<string, Product>();
  makesProducts = false;
  get maxProducts() {
    if (!this.makesProducts) return 0;

    // Calculate additional number of allowed Products from Research/Upgrades
    let additional = 0;
    if (this.hasResearch("uPgrade: Capacity.I")) ++additional;
    if (this.hasResearch("uPgrade: Capacity.II")) ++additional;

    return corpConstants.maxProductsBase + additional;
  }

  awareness = 0;
  popularity = 0;
  startingCost = 0;

  /* The following are factors for how much production/other things are increased by
       different factors. The production increase always has diminishing returns,
       and they are all represented by exponentials of < 1 (e.g x ^ 0.5, x ^ 0.8)
       The number for these represent the exponential. A lower number means more
       diminishing returns */
  realEstateFactor = 0;
  researchFactor = 0;
  hardwareFactor = 0;
  robotFactor = 0;
  aiCoreFactor = 0;
  advertisingFactor = 0;

  productionMult = 1; //Production multiplier

  //Financials
  lastCycleRevenue = 0;
  lastCycleExpenses = 0;
  thisCycleRevenue = 0;
  thisCycleExpenses = 0;

  newInd = true;

  // Sector 12 office and warehouse are added by default, these entries are added in the constructor.
  warehouses: PartialRecord<CityName, Warehouse> = {};
  offices: PartialRecord<CityName, OfficeSpace> = {};

  numAdVerts = 0;

  constructor(params: DivisionParams | null = null) {
    if (!params) return;
    // Must be initialized inside the constructor because it references the industry
    this.industry = params.industry;
    this.name = params.name;
    // Add default starting
    this.warehouses[CityName.Sector12] = new Warehouse({
      loc: CityName.Sector12,
      division: this,
      size: corpConstants.warehouseInitialSize,
    });
    this.offices[CityName.Sector12] = new OfficeSpace({
      city: CityName.Sector12,
      size: corpConstants.officeInitialSize,
    });

    // Loading data based on this division's industry type
    const data = IndustriesData[this.industry];
    this.startingCost = data.startingCost;
    this.makesProducts = data.makesProducts;
    this.realEstateFactor = data.realEstateFactor ?? 0;
    this.researchFactor = data.scienceFactor ?? 0;
    this.hardwareFactor = data.hardwareFactor ?? 0;
    this.robotFactor = data.robotFactor ?? 0;
    this.aiCoreFactor = data.aiCoreFactor ?? 0;
    this.advertisingFactor = data.advertisingFactor ?? 0;
    this.requiredMaterials = data.requiredMaterials;
    this.producedMaterials = data.producedMaterials ?? [];
  }

  hasMaximumNumberProducts(): boolean {
    return this.products.size >= this.maxProducts;
  }

  //Calculates the values that factor into the production and properties of
  //materials/products (such as quality, etc.)
  calculateProductionFactors(): void {
    let multSum = 0;
    for (const warehouse of getRecordValues(this.warehouses)) {
      const materials = warehouse.materials;

      const cityMult =
        Math.pow(0.002 * materials["Real Estate"].stored + 1, this.realEstateFactor) *
        Math.pow(0.002 * materials.Hardware.stored + 1, this.hardwareFactor) *
        Math.pow(0.002 * materials.Robots.stored + 1, this.robotFactor) *
        Math.pow(0.002 * materials["AI Cores"].stored + 1, this.aiCoreFactor);
      multSum += Math.pow(cityMult, 0.73);
    }

    multSum < 1 ? (this.productionMult = 1) : (this.productionMult = multSum);
  }

  calculateRecoupableValue(): number {
    let price = this.startingCost;
    for (const city of getRecordKeys(this.offices)) {
      if (city === CityName.Sector12) continue;
      price += corpConstants.officeInitialCost;
      if (this.warehouses[city]) price += corpConstants.warehouseInitialCost;
    }
    price /= 2;
    return price;
  }

  updateWarehouseSizeUsed(warehouse: Warehouse): void {
    warehouse.updateMaterialSizeUsed();

    for (const prod of this.products.values()) {
      warehouse.sizeUsed += prod.cityData[warehouse.city].stored * prod.size;
    }
  }

  process(marketCycles = 1, corporation: Corporation): void {
    const state = corporation.state.nextName;
    //At the start of a cycle, store and reset revenue/expenses
    //Then calculate salaries and process the markets
    if (state === "START") {
      if (isNaN(this.thisCycleRevenue) || isNaN(this.thisCycleExpenses)) {
        exceptionAlert(
          new Error(
            `Invalid revenue/expenses. thisCycleRevenue: ${this.thisCycleRevenue}. thisCycleExpenses: ${this.thisCycleExpenses}`,
          ),
          true,
        );
        this.thisCycleRevenue = 0;
        this.thisCycleExpenses = 0;
      }
      this.lastCycleRevenue = this.thisCycleRevenue / (marketCycles * corpConstants.secondsPerMarketCycle);
      this.lastCycleExpenses = this.thisCycleExpenses / (marketCycles * corpConstants.secondsPerMarketCycle);
      this.thisCycleRevenue = 0;
      this.thisCycleExpenses = 0;

      // Once you start making revenue, the player should no longer be
      // considered new, and therefore no longer needs the 'tutorial' UI elements
      if (this.lastCycleRevenue > 0) {
        this.newInd = false;
      }

      // Process offices (and the employees in them)
      let employeeSalary = 0;
      for (const officeLoc of Object.values(CityName)) {
        const office = this.offices[officeLoc];
        if (office) employeeSalary += office.process(marketCycles, corporation, this);
      }
      this.thisCycleExpenses = this.thisCycleExpenses + employeeSalary;

      // Process change in demand/competition of materials/products
      this.processMaterialMarket();
      this.processProductMarket(marketCycles);

      // Process loss of popularity
      this.popularity -= marketCycles * 0.0001;
      this.popularity = Math.max(0, this.popularity);

      return;
    }

    // Process production, purchase, and import/export of materials
    let res = this.processMaterials(marketCycles, corporation);
    if (Array.isArray(res)) {
      this.thisCycleRevenue = this.thisCycleRevenue + res[0];
      this.thisCycleExpenses = this.thisCycleExpenses + res[1];
    }

    // Process creation, production & sale of products
    res = this.processProducts(marketCycles, corporation);
    if (Array.isArray(res)) {
      this.thisCycleRevenue = this.thisCycleRevenue + res[0];
      this.thisCycleExpenses = this.thisCycleExpenses + res[1];
    }
  }

  // Process demand, competition, and market price changes for this division's materials
  processMaterialMarket(): void {
    // Relevant materials:
    // - All materials this division requires or produces
    // - Boost materials
    const materials = new Set([
      ...getRecordKeys(this.requiredMaterials),
      ...this.producedMaterials,
      ...corpConstants.boostMaterials,
    ]);

    for (const city of Object.values(CityName)) {
      const warehouse = this.warehouses[city];
      // If this division has a warehouse in this city, process the relevant materials
      if (warehouse == null) {
        continue;
      }
      for (const materialName of materials) {
        warehouse.materials[materialName].processMarket();
      }
    }
  }

  // Process change in demand and competition for this industry's products
  processProductMarket(marketCycles = 1): void {
    // Demand gradually decreases, and competition gradually increases
    for (const product of this.products.values()) {
      let change = getRandomIntInclusive(0, 3) * 0.0004;
      if (change === 0) continue;

      if (
        this.industry === IndustryType.Pharmaceutical ||
        this.industry === IndustryType.Software ||
        this.industry === IndustryType.Robotics
      ) {
        change *= 3;
      }
      change *= marketCycles;
      product.demand -= change;
      product.competition += change;
      product.competition = Math.min(product.competition, 99.99);
      product.demand = Math.max(product.demand, 0.001);
    }
  }

  processSaleState(
    marketCycles: number,
    item: Material | Product,
    corporation: Corporation,
    office: OfficeSpace,
    warehouse: Warehouse,
  ): number {
    let revenue = 0;
    const city = office.city;
    const isMaterial = item instanceof Material;

    if (isMaterial) {
      if ((typeof item.desiredSellPrice === "number" && item.desiredSellPrice < 0) || item.desiredSellAmount === 0) {
        item.actualSellAmount = 0;
        return 0;
      }
    } else {
      item.cityData[city].productionCost = 0;
      for (const [reqMatName, reqQty] of getRecordEntries(item.requiredMaterials)) {
        item.cityData[city].productionCost += reqQty * warehouse.materials[reqMatName].marketPrice;
      }
      // With products, the production cost is increased for labor
      item.cityData[city].productionCost *= corpConstants.baseProductProfitMult;
    }

    let stored;
    let desiredSellAmount;
    let desiredSellPrice;
    let productionAmount;
    let name;
    let marketTa1;
    let marketTa2;
    let marketPrice;
    let markupLimit;
    let qualityAndEffectiveRatingFactor;
    if (isMaterial) {
      stored = item.stored;
      desiredSellAmount = item.desiredSellAmount;
      desiredSellPrice = item.desiredSellPrice;
      productionAmount = item.productionAmount;
      name = item.name;
      marketTa1 = item.marketTa1;
      marketTa2 = item.marketTa2;
      marketPrice = item.marketPrice;
      markupLimit = item.getMarkupLimit();
      qualityAndEffectiveRatingFactor = item.quality + 0.001;
    } else {
      stored = item.cityData[city].stored;
      desiredSellAmount = item.cityData[city].desiredSellAmount;
      desiredSellPrice = item.cityData[city].desiredSellPrice;
      productionAmount = item.cityData[city].productionAmount;
      name = item.name;
      marketTa1 = item.marketTa1;
      marketTa2 = item.marketTa2;
      marketPrice = item.cityData[city].productionCost;
      if (item.markup === 0) {
        exceptionAlert(new Error(`Markup of product ${item.name} is 0`));
        item.markup = 1;
      }
      markupLimit = Math.max(item.cityData[city].effectiveRating, 0.001) / item.markup;
      qualityAndEffectiveRatingFactor = 0.5 * Math.pow(item.cityData[city].effectiveRating, 0.65);
    }

    // Sale multipliers
    const businessFactor = this.getBusinessFactor(office); // Business employee productivity
    const advertisingFactor = this.getAdvertisingFactors()[0]; // Awareness + popularity
    const marketFactor = this.getMarketFactor(item); // Competition + demand

    // Parse player sell-amount input (needed for TA.II and selling)
    let sellAmt: number;
    // The amount gets re-multiplied later, so this is the correct
    // amount to calculate with for "MAX".
    const adjustedQty = stored / (corpConstants.secondsPerMarketCycle * marketCycles);
    /**
     * desiredSellAmount is usually a string, but it also can be a number in old versions. eval requires a
     * string, so we convert it to a string here, replace placeholders, and then pass it to eval.
     */
    let temp = String(desiredSellAmount);
    temp = temp.replace(/MAX/g, adjustedQty.toString());
    temp = temp.replace(/PROD/g, productionAmount.toString());
    temp = temp.replace(/INV/g, stored.toString());
    try {
      // Typecasting here is fine. We will validate the result immediately after this line.
      sellAmt = eval?.(temp) as number;
      if (typeof sellAmt !== "number" || !Number.isFinite(sellAmt)) {
        throw new Error(`Evaluated value is not a valid number: ${sellAmt}`);
      }
    } catch (error) {
      dialogBoxCreate(
        `Error evaluating your sell amount for ${name} in ${this.name}'s ${city} office. Error: ${error}.`,
      );
      return 0;
    }
    // sellAmt must be a non-negative number.
    if (sellAmt < 0) {
      sellAmt = 0;
    }

    // Calculate Sale Cost (sCost), which could be dynamically evaluated
    let sCost: number;
    if (marketTa2) {
      // Reverse engineer the 'maxSell' formula
      // 1. Set 'maxSell' = sellAmt
      // 2. Substitute formula for 'markup'
      // 3. Solve for 'sCost'
      const sqrtDenominator =
        qualityAndEffectiveRatingFactor *
        marketFactor *
        businessFactor *
        corporation.getSalesMult() *
        advertisingFactor *
        this.getSalesMultiplier();
      const denominator = Math.sqrt(sellAmt / sqrtDenominator);
      let optimalPrice;
      if (sqrtDenominator === 0 || denominator === 0) {
        if (sellAmt === 0) {
          optimalPrice = 0; // Nothing to sell
        } else {
          optimalPrice = marketPrice + markupLimit;
          console.warn(`In Corporation, found illegal 0s when trying to calculate MarketTA2 sale cost`);
        }
      } else {
        optimalPrice = markupLimit / denominator + marketPrice;
      }

      // Store this "optimal price" in a property so we don't have to re-calculate it for the UI.
      sCost = optimalPrice;
    } else if (marketTa1) {
      sCost = marketPrice + markupLimit;
    } else {
      // If the player does not set the price, desiredSellPrice will be an empty string.
      if (desiredSellPrice === "") {
        return 0;
      }
      /**
       * desiredSellPrice is usually a string, but it also can be a number in old versions. eval requires a
       * string, so we convert it to a string here, replace the placeholder MP, and then pass it to eval later.
       */
      const temp = String(desiredSellPrice).replace(/MP/g, marketPrice.toString());
      try {
        // Typecasting here is fine. We will validate the result immediately after this line.
        sCost = eval?.(temp) as number;
        if (typeof sCost !== "number" || !Number.isFinite(sCost)) {
          throw new Error(`Evaluated value is not a valid number: ${sCost}`);
        }
      } catch (error) {
        dialogBoxCreate(
          `Error evaluating your sell price for ${name} in ${this.name}'s ${city} office. ` +
            `The sell amount is being set to zero. Error: ${error}`,
        );
        return 0;
      }
    }
    if (isMaterial) {
      item.uiMarketPrice = sCost;
    } else {
      item.uiMarketPrice[city] = sCost;
    }

    const markupMultiplier = calculateMarkupMultiplier(sCost, marketPrice, markupLimit);

    // Calculate how much of the material sells (per second)
    const maxSellPerCycle =
      qualityAndEffectiveRatingFactor *
      marketFactor *
      markupMultiplier *
      businessFactor *
      corporation.getSalesMult() *
      advertisingFactor *
      this.getSalesMultiplier();
    if (isMaterial) {
      item.maxSellPerCycle = maxSellPerCycle;
    } else {
      item.maxSellAmount = maxSellPerCycle;
    }

    sellAmt = Math.min(maxSellPerCycle, sellAmt);
    sellAmt = sellAmt * corpConstants.secondsPerMarketCycle * marketCycles;
    sellAmt = Math.min(stored, sellAmt);
    const setActualSellAmount = (value: number) => {
      if (isMaterial) {
        item.actualSellAmount = value;
      } else {
        item.cityData[city].actualSellAmount = value;
      }
    };
    if (sellAmt < 0) {
      console.error(`sellAmt calculated to be negative for ${name} in ${this.name}'s ${city}`);
      setActualSellAmount(0);
      return 0;
    }
    if (sellAmt && sCost >= 0) {
      if (isMaterial) {
        item.stored -= sellAmt;
      } else {
        item.cityData[city].stored -= sellAmt;
      }
      revenue += sellAmt * sCost;
      setActualSellAmount(sellAmt / (corpConstants.secondsPerMarketCycle * marketCycles));
    } else {
      setActualSellAmount(0);
    }
    return revenue;
  }

  //Process production, purchase, and import/export of materials
  processMaterials(marketCycles = 1, corporation: Corporation): [number, number] {
    const state = corporation.state.nextName;
    let revenue = 0;
    let expenses = 0;
    this.calculateProductionFactors();

    for (const [city, office] of getRecordEntries(this.offices)) {
      // Research points can be created even without a warehouse
      this.researchPoints +=
        // Todo: add constant for magic number
        0.004 *
        Math.pow(office.employeeProductionByJob[CorpEmployeeJob.RandD], 0.5) *
        corporation.getScientificResearchMult() *
        this.getScientificResearchMultiplier();

      // Employee pay is an expense even with no warehouse.
      expenses += office.totalSalary;

      const warehouse = this.warehouses[city];
      if (!warehouse) continue;

      switch (state) {
        case "PURCHASE": {
          const smartBuy: PartialRecord<CorpMaterialName, [buyAmt: number, reqMat: number]> = {};

          /* Process purchase of materials, not from smart supply */
          for (const [matName, mat] of getRecordEntries(warehouse.materials)) {
            const reqMat = this.requiredMaterials[matName];
            if (warehouse.smartSupplyEnabled && reqMat) {
              // Smart supply
              mat.buyAmount = reqMat * warehouse.smartSupplyStore;
              let buyAmt = mat.buyAmount * corpConstants.secondsPerMarketCycle * marketCycles;
              const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / MaterialInfo[matName].size);
              buyAmt = Math.min(buyAmt, maxAmt);
              if (buyAmt > 0) smartBuy[matName] = [buyAmt, reqMat];
            } else {
              // Not smart supply
              let buyAmt = 0;
              let maxAmt = 0;

              buyAmt = mat.buyAmount * corpConstants.secondsPerMarketCycle * marketCycles;

              maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / MaterialInfo[matName].size);

              buyAmt = Math.min(buyAmt, maxAmt);
              if (buyAmt > 0) {
                mat.quality = Math.max(0.1, (mat.quality * mat.stored + 1 * buyAmt) / (mat.stored + buyAmt));
                mat.averagePrice = (mat.stored * mat.averagePrice + buyAmt * mat.marketPrice) / (mat.stored + buyAmt);
                mat.stored += buyAmt;
                expenses += buyAmt * mat.marketPrice;
              }
              this.updateWarehouseSizeUsed(warehouse);
            }
          } //End process purchase of materials

          // Find which material were trying to create the least amount of product with.
          let worseAmt = 1e99;
          for (const [buyAmt, reqMat] of Object.values(smartBuy)) {
            const amt = buyAmt / reqMat;
            if (amt < worseAmt) worseAmt = amt;
          }

          // Align all the materials to the smallest amount.
          for (const buyArray of Object.values(smartBuy)) {
            buyArray[0] = worseAmt * buyArray[1];
          }

          // Calculate the total size of all things were trying to buy
          let totalSize = 0;
          for (const [matName, [buyAmt]] of getRecordEntries(smartBuy)) {
            if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
            totalSize += buyAmt * MaterialInfo[matName].size;
          }

          // Shrink to the size of available space.
          const freeSpace = warehouse.size - warehouse.sizeUsed;
          if (totalSize > freeSpace) {
            // Multiplier applied to buy amounts to not overfill warehouse
            const buyMult = freeSpace / totalSize;
            for (const buyArray of Object.values(smartBuy)) {
              buyArray[0] = Math.floor(buyArray[0] * buyMult);
            }
          }

          // Use the materials already in the warehouse if the option is on.
          for (const [matName, buyArray] of getRecordEntries(smartBuy)) {
            if (warehouse.smartSupplyOptions[matName] === "none") continue;
            const mat = warehouse.materials[matName];
            if (warehouse.smartSupplyOptions[matName] === "leftovers") {
              buyArray[0] = Math.max(0, buyArray[0] - mat.stored);
            } else {
              buyArray[0] = Math.max(
                0,
                buyArray[0] - mat.importAmount * corpConstants.secondsPerMarketCycle * marketCycles,
              );
            }
          }

          // buy them
          for (const [matName, [buyAmt]] of getRecordEntries(smartBuy)) {
            const mat = warehouse.materials[matName];
            if (mat.stored + buyAmt !== 0) {
              mat.quality = (mat.quality * mat.stored + 1 * buyAmt) / (mat.stored + buyAmt);
              mat.averagePrice = (mat.averagePrice * mat.stored + mat.marketPrice * buyAmt) / (mat.stored + buyAmt);
            } else {
              mat.quality = 1;
              mat.averagePrice = mat.marketPrice;
            }
            mat.stored += buyAmt;
            mat.buyAmount = buyAmt / (corpConstants.secondsPerMarketCycle * marketCycles);
            expenses += buyAmt * mat.marketPrice;
          }
          break;
        }
        case "PRODUCTION":
          warehouse.smartSupplyStore = 0; //Reset smart supply amount

          /* Process production of materials */
          if (this.producedMaterials.length > 0) {
            //Calculate the maximum production of this material based
            //on the office's productivity
            const maxProd =
              this.getOfficeProductivity(office) *
              this.productionMult * // Multiplier from boost materials
              corporation.getProductionMultiplier() *
              this.getProductionMultiplier(); // Multiplier from Research

            // Convert production from per second to per market cycle
            let prod = maxProd * corpConstants.secondsPerMarketCycle * marketCycles;

            // Calculate net change in warehouse storage making the produced materials will cost
            let totalMatSize = 0;
            for (let tmp = 0; tmp < this.producedMaterials.length; ++tmp) {
              totalMatSize += MaterialInfo[this.producedMaterials[tmp]].size;
            }
            for (const [reqMatName, reqQty] of getRecordEntries(this.requiredMaterials)) {
              totalMatSize -= MaterialInfo[reqMatName].size * reqQty;
            }
            // If not enough space in warehouse, limit the amount of produced materials
            if (totalMatSize > 0) {
              const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / totalMatSize);
              prod = Math.min(maxAmt, prod);
            }

            if (prod < 0) {
              prod = 0;
            }

            // Keep track of production for smart supply (/s)
            warehouse.smartSupplyStore += prod / (corpConstants.secondsPerMarketCycle * marketCycles);

            // Make sure we have enough resource to make our materials
            let producableFrac = 1;
            for (const [reqMatName, reqMat] of getRecordEntries(this.requiredMaterials)) {
              const req = reqMat * prod;
              if (warehouse.materials[reqMatName].stored < req) {
                producableFrac = Math.min(producableFrac, warehouse.materials[reqMatName].stored / req);
              }
            }
            if (producableFrac <= 0) {
              producableFrac = 0;
              prod = 0;
            }

            // Make our materials if they are producable
            if (producableFrac > 0 && prod > 0) {
              const requiredMatsEntries = getRecordEntries(this.requiredMaterials);
              let avgQlt = 0;
              const divider = requiredMatsEntries.length;
              for (const [reqMatName, reqMat] of requiredMatsEntries) {
                const reqMatQtyNeeded = reqMat * prod * producableFrac;
                // producableFrac already takes into account that we have enough stored
                // Math.max is used here to avoid stored becoming negative (which can lead to NaNs)
                /**
                 * material.stored can become negative due to floating-point inaccuracy.
                 *
                 * Let's check this situation: Tobacco: 1 Plants -> 1 Product. In this situation, we have:
                 * - reqQty = 1
                 * - producableFrac = material.stored / prod
                 * - reqMatQtyNeeded = prod * material.stored / prod
                 *
                 * Due to floating-point inaccuracy, "prod * material.stored / prod" may be slightly greater than
                 * "material.stored". Example numbers from a real test run:
                 * - warehouse.materials[reqMatName].stored: 942118
                 * - prod: 176915618.50773352
                 * - producableFrac: 0.005325239274783516
                 * - reqMatQtyNeeded: 942118.0000000001
                 */
                warehouse.materials[reqMatName].stored = Math.max(
                  0,
                  warehouse.materials[reqMatName].stored - reqMatQtyNeeded,
                );
                warehouse.materials[reqMatName].productionAmount = 0;
                warehouse.materials[reqMatName].productionAmount -=
                  reqMatQtyNeeded / (corpConstants.secondsPerMarketCycle * marketCycles);

                avgQlt += warehouse.materials[reqMatName].quality / divider;
              }
              avgQlt = Math.max(avgQlt, 1);
              for (let j = 0; j < this.producedMaterials.length; ++j) {
                let outputAmount = prod * producableFrac;
                const productionLimit = warehouse.materials[this.producedMaterials[j]].productionLimit;
                if (productionLimit !== null) {
                  // productionLimit is per second, so we need to convert it to per market cycle.
                  const effectiveLimitValue = productionLimit * corpConstants.secondsPerMarketCycle * marketCycles;
                  outputAmount = Math.min(outputAmount, effectiveLimitValue);
                }

                let tempQlt =
                  office.employeeProductionByJob[CorpEmployeeJob.Engineer] / 90 +
                  Math.pow(this.researchPoints, this.researchFactor) +
                  Math.pow(Math.max(0, warehouse.materials["AI Cores"].stored), this.aiCoreFactor) / 10e3;
                const logQlt = Math.max(Math.pow(tempQlt, 0.5), 1);
                tempQlt = Math.min(tempQlt, avgQlt * logQlt);
                warehouse.materials[this.producedMaterials[j]].quality = Math.max(
                  1,
                  (warehouse.materials[this.producedMaterials[j]].quality *
                    warehouse.materials[this.producedMaterials[j]].stored +
                    tempQlt * outputAmount) /
                    (warehouse.materials[this.producedMaterials[j]].stored + outputAmount),
                );
                warehouse.materials[this.producedMaterials[j]].averagePrice =
                  (warehouse.materials[this.producedMaterials[j]].averagePrice *
                    warehouse.materials[this.producedMaterials[j]].stored +
                    warehouse.materials[this.producedMaterials[j]].marketPrice * outputAmount) /
                  (warehouse.materials[this.producedMaterials[j]].stored + outputAmount);

                warehouse.materials[this.producedMaterials[j]].stored += outputAmount;
                warehouse.materials[this.producedMaterials[j]].productionAmount =
                  outputAmount / (corpConstants.secondsPerMarketCycle * marketCycles);
              }
            } else {
              for (const reqMatName of getRecordKeys(this.requiredMaterials)) {
                warehouse.materials[reqMatName].productionAmount = 0;
              }
            }
          } else {
            //If this doesn't produce any materials, then it only creates
            //Products. Creating products will consume materials. The
            //Production of all consumed materials must be set to 0
            for (const reqMatName of getRecordKeys(this.requiredMaterials)) {
              warehouse.materials[reqMatName].productionAmount = 0;
            }
          }
          break;

        case "SALE":
          /* Process sale of materials */
          for (const material of getRecordValues(warehouse.materials)) {
            revenue += this.processSaleState(marketCycles, material, corporation, office, warehouse);
          }
          break;

        case "EXPORT":
          for (const matName of Object.values(corpConstants.materialNames)) {
            if (Object.hasOwn(warehouse.materials, matName)) {
              const mat = warehouse.materials[matName];
              mat.exportedLastCycle = 0; //Reset export
              for (let expI = 0; expI < mat.exports.length; ++expI) {
                const exp = mat.exports[expI];

                const expIndustry = corporation.divisions.get(exp.division);
                if (!expIndustry) {
                  console.error(`Invalid export! ${exp.division}`);
                  continue;
                }
                const expWarehouse = expIndustry.warehouses[exp.city];
                if (!expWarehouse) {
                  console.error(`Invalid export! ${expIndustry.name} ${exp.city}`);
                  continue;
                }
                const tempMaterial = expWarehouse.materials[matName];

                let amtStr = exp.amount.replace(
                  /MAX/g,
                  (mat.stored / (corpConstants.secondsPerMarketCycle * marketCycles)).toString(),
                );
                amtStr = amtStr.replace(/EPROD/g, `(${mat.productionAmount})`);
                amtStr = amtStr.replace(/IPROD/g, `(${tempMaterial.productionAmount})`);
                amtStr = amtStr.replace(/EINV/g, `(${mat.stored})`);
                amtStr = amtStr.replace(/IINV/g, `(${tempMaterial.stored})`);
                let amt = 0;
                try {
                  // Typecasting here is fine. We will validate the result immediately after this line.
                  amt = eval?.(amtStr) as number;
                  if (typeof amt !== "number" || !Number.isFinite(amt)) {
                    throw new Error(`Evaluated value is not a valid number: ${amt}`);
                  }
                } catch (e) {
                  dialogBoxCreate(
                    `Calculating export for ${mat.name} in ${this.name}'s ${city} division failed with error: ${e}`,
                  );
                  continue;
                }
                amt = amt * corpConstants.secondsPerMarketCycle * marketCycles;

                if (mat.stored < amt) {
                  amt = mat.stored;
                }

                // Make sure theres enough space in warehouse
                if (expWarehouse.sizeUsed >= expWarehouse.size) {
                  // Warehouse at capacity. Exporting doesn't
                  // affect revenue so just return 0's
                  continue;
                } else {
                  const maxAmt = Math.floor((expWarehouse.size - expWarehouse.sizeUsed) / MaterialInfo[matName].size);
                  amt = Math.min(maxAmt, amt);
                }
                if (amt <= 0) {
                  continue;
                }
                expWarehouse.materials[matName].importAmount +=
                  amt / (corpConstants.secondsPerMarketCycle * marketCycles);

                //Pretty sure this can cause some issues if there are multiple sources importing same material to same warehouse
                //but this will do for now
                expWarehouse.materials[matName].quality = Math.max(
                  0.1,
                  (expWarehouse.materials[matName].quality * expWarehouse.materials[matName].stored +
                    amt * mat.quality) /
                    (expWarehouse.materials[matName].stored + amt),
                );

                expWarehouse.materials[matName].averagePrice =
                  (expWarehouse.materials[matName].averagePrice * expWarehouse.materials[matName].stored +
                    expWarehouse.materials[matName].marketPrice * amt) /
                  (expWarehouse.materials[matName].stored + amt);
                expWarehouse.materials[matName].stored += amt;
                mat.stored -= amt;
                mat.exportedLastCycle += amt;
                expIndustry.updateWarehouseSizeUsed(expWarehouse);
              }
              //totalExp should be per second
              mat.exportedLastCycle /= corpConstants.secondsPerMarketCycle * marketCycles;
            }
          }

          break;

        case "START":
          break;
        default:
          throwIfReachable(state);
      } //End switch(this.state)
      this.updateWarehouseSizeUsed(warehouse);
    }
    return [revenue, expenses];
  }

  /** Process product development and production/sale */
  processProducts(marketCycles = 1, corporation: Corporation): [number, number] {
    const state = corporation.state.nextName;
    let revenue = 0;
    const expenses = 0;

    //Create products
    for (const [name, product] of this.products) {
      if (!product.finished) {
        // Product still under development
        if (state !== "PRODUCTION") continue;
        const city = product.creationCity;
        const office = this.offices[city];
        if (!office) {
          console.error(`Product ${name} being created in a city without an office. This is a bug.`);
          continue;
        }
        product.createProduct(marketCycles, office.employeeProductionByJob);
        if (product.developmentProgress >= 100) {
          product.finishProduct(this);
        }
        break;
      } else {
        revenue += this.processProduct(marketCycles, product, corporation);
      }
    }
    return [revenue, expenses];
  }

  //Processes FINISHED products
  processProduct(marketCycles = 1, product: Product, corporation: Corporation): number {
    const state = corporation.state.nextName;
    let totalProfit = 0;
    for (const [city, office] of getRecordEntries(this.offices)) {
      const warehouse = this.warehouses[city];
      if (!warehouse) continue;
      switch (state) {
        case "PRODUCTION": {
          //Calculate the maximum production of this product based
          //on the office's productivity
          const maxProd =
            this.getOfficeProductivity(office, { forProduct: true }) *
            corporation.getProductionMultiplier() *
            this.productionMult * // Multiplier from boost materials
            this.getProductionMultiplier() * // Multiplier from research
            this.getProductProductionMultiplier(); // Multiplier from research
          let prod;

          const productionLimit = product.cityData[city].productionLimit;
          //Account for whether production is manually limited
          if (productionLimit !== null) {
            prod = Math.min(maxProd, productionLimit);
          } else {
            prod = maxProd;
          }
          prod *= corpConstants.secondsPerMarketCycle * marketCycles;

          // The "netStorageSize" check is redundant, but retained in case the product size calculation changes.
          //Calculate net change in warehouse storage making the Products will cost
          let netStorageSize = product.size;
          for (const [reqMatName, reqQty] of getRecordEntries(product.requiredMaterials)) {
            netStorageSize -= MaterialInfo[reqMatName].size * reqQty;
          }
          //If there's not enough space in warehouse, limit the amount of Product
          if (netStorageSize > 0) {
            const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / netStorageSize);
            prod = Math.min(maxAmt, prod);
          }

          warehouse.smartSupplyStore += prod / (corpConstants.secondsPerMarketCycle * marketCycles);

          //Make sure we have enough resources to make our Products
          let producableFrac = 1;
          for (const [reqMatName, reqQty] of getRecordEntries(product.requiredMaterials)) {
            const req = reqQty * prod;
            if (warehouse.materials[reqMatName].stored < req) {
              producableFrac = Math.min(producableFrac, warehouse.materials[reqMatName].stored / req);
            }
          }

          //Make our Products if they are producable
          if (producableFrac > 0 && prod > 0) {
            let avgQlt = 1;
            for (const [reqMatName, reqQty] of getRecordEntries(product.requiredMaterials)) {
              const reqMatQtyNeeded = reqQty * prod * producableFrac;
              // producableFrac already takes into account that we have enough stored
              // Math.max is used here to avoid stored becoming negative (which can lead to NaNs)
              /**
               * material.stored can become negative due to floating-point inaccuracy.
               *
               * Let's check this situation: Tobacco: 1 Plants -> 1 Product. In this situation, we have:
               * - reqQty = 1
               * - producableFrac = material.stored / prod
               * - reqMatQtyNeeded = prod * material.stored / prod
               *
               * Due to floating-point inaccuracy, "prod * material.stored / prod" may be slightly greater than
               * "material.stored". Example numbers from a real test run:
               * - warehouse.materials[reqMatName].stored: 942118
               * - prod: 176915618.50773352
               * - producableFrac: 0.005325239274783516
               * - reqMatQtyNeeded: 942118.0000000001
               */
              warehouse.materials[reqMatName].stored = Math.max(
                0,
                warehouse.materials[reqMatName].stored - reqMatQtyNeeded,
              );
              warehouse.materials[reqMatName].productionAmount -=
                reqMatQtyNeeded / (corpConstants.secondsPerMarketCycle * marketCycles);
              avgQlt += warehouse.materials[reqMatName].quality;
            }
            avgQlt /= Object.keys(product.requiredMaterials).length;
            const tempEffRat = Math.min(product.rating, avgQlt * Math.pow(product.rating, 0.5));
            //Effective Rating
            product.cityData[city].effectiveRating =
              (product.cityData[city].effectiveRating * product.cityData[city].stored +
                tempEffRat * prod * producableFrac) /
              (product.cityData[city].stored + prod * producableFrac);
            //Quantity
            product.cityData[city].stored += prod * producableFrac;
          }

          //Keep track of production Per second
          product.cityData[city].productionAmount =
            (prod * producableFrac) / (corpConstants.secondsPerMarketCycle * marketCycles);
          break;
        }
        case "SALE":
          totalProfit += this.processSaleState(marketCycles, product, corporation, office, warehouse);
          break;
        case "START":
        case "PURCHASE":
        case "EXPORT":
          break;
        default:
          throwIfReachable(state);
      } //End switch(this.state)
      this.updateWarehouseSizeUsed(warehouse);
    }
    return totalProfit;
  }

  resetImports(state: CorpStateName): void {
    //At the start of the export state, set the imports of everything to 0
    if (state === "EXPORT") {
      for (const warehouse of getRecordValues(this.warehouses)) {
        for (const material of getRecordValues(warehouse.materials)) {
          material.importAmount = 0;
        }
      }
    }
  }

  discontinueProduct(productName: string): void {
    this.products.delete(productName);
  }

  getAdVertCost(): number {
    return 1e9 * Math.pow(1.06, this.numAdVerts);
  }

  applyAdVert(corporation: Corporation): void {
    const advMult = corporation.getAdvertisingMultiplier() * this.getAdvertisingMultiplier();
    const awareness = (this.awareness + 3 * advMult) * (1.005 * advMult);
    this.awareness = Math.min(awareness, Number.MAX_VALUE);

    const popularity = (this.popularity + 1 * advMult) * ((1 + getRandomIntInclusive(1, 3) / 200) * advMult);
    this.popularity = Math.min(popularity, Number.MAX_VALUE);

    ++this.numAdVerts;
  }

  // Returns how much of a material can be produced based of office productivity (employee stats)
  getOfficeProductivity(office: OfficeSpace, params: { forProduct?: boolean } = {}): number {
    const opProd = office.employeeProductionByJob[CorpEmployeeJob.Operations];
    const engrProd = office.employeeProductionByJob[CorpEmployeeJob.Engineer];
    const mgmtProd = office.employeeProductionByJob[CorpEmployeeJob.Management];
    const total = opProd + engrProd + mgmtProd;

    if (total <= 0) return 0;

    // Management is a multiplier for the production from Operations and Engineers
    const mgmtFactor = 1 + mgmtProd / (1.2 * total);

    // For production, Operations is slightly more important than engineering
    // Both Engineering and Operations have diminishing returns
    const prod = (Math.pow(opProd, 0.4) + Math.pow(engrProd, 0.3)) * mgmtFactor;

    // Generic multiplier for the production. Used for game-balancing purposes
    const balancingMult = 0.05;

    if (params && params.forProduct) {
      // Products are harder to create and therefore have less production
      return 0.5 * balancingMult * prod;
    } else {
      return balancingMult * prod;
    }
  }

  // Returns a multiplier based on the office' 'Business' employees that affects sales
  getBusinessFactor(office: OfficeSpace): number {
    const businessProd = 1 + office.employeeProductionByJob[CorpEmployeeJob.Business];

    return calculateEffectWithFactors(businessProd, 0.26, 10e3);
  }

  //Returns a set of multipliers based on the Industry's awareness, popularity, and advFac. This
  //multiplier affects sales. The result is:
  //  [Total sales mult, total awareness mult, total pop mult, awareness/pop ratio mult]
  getAdvertisingFactors(): [
    totalFactor: number,
    awarenessFactor: number,
    popularityFactor: number,
    ratioFactor: number,
  ] {
    const awarenessFac = Math.pow(this.awareness + 1, this.advertisingFactor);
    const popularityFac = Math.pow(this.popularity + 1, this.advertisingFactor);
    const ratioFac = this.awareness === 0 ? 0.01 : Math.max((this.popularity + 0.001) / this.awareness, 0.01);
    const totalFac = Math.pow(awarenessFac * popularityFac * ratioFac, 0.85);
    return [totalFac, awarenessFac, popularityFac, ratioFac];
  }

  //Returns a multiplier based on a materials demand and competition that affects sales
  getMarketFactor(item: Material | Product): number {
    return Math.max(0.1, (item.demand * (100 - item.competition)) / 100);
  }

  // Returns a boolean indicating whether this Industry has the specified Research
  hasResearch(name: CorpResearchName): boolean {
    return this.researched.has(name);
  }

  updateResearchTree(): void {
    if (this.treeInitialized) return;
    const researchTree = IndustryResearchTrees[this.industry];
    // Need to populate the tree in case we are loading a game.
    for (const research of this.researched) researchTree.research(research);
    // Also need to load researches from the tree in case we are making a new division.
    for (const research of researchTree.researched) this.researched.add(research);
    this.treeInitialized = true;
  }

  // Get multipliers from Research
  getAdvertisingMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getAdvertisingMultiplier();
  }

  getEmployeeChaMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getEmployeeChaMultiplier();
  }

  getEmployeeCreMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getEmployeeCreMultiplier();
  }

  getEmployeeEffMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getEmployeeEffMultiplier();
  }

  getEmployeeIntMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getEmployeeIntMultiplier();
  }

  getProductionMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getProductionMultiplier();
  }

  getProductProductionMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getProductProductionMultiplier();
  }

  getSalesMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getSalesMultiplier();
  }

  getScientificResearchMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getScientificResearchMultiplier();
  }

  getStorageMultiplier(): number {
    const researchTree = IndustryResearchTrees[this.industry];
    this.updateResearchTree();
    return researchTree.getStorageMultiplier();
  }

  /** Serialize the current object to a JSON save state. */
  toJSON(): IReviverValue {
    return Generic_toJSON("Division", this, Division.includedKeys);
  }

  /** Initializes a Division object from a JSON save state. */
  static fromJSON(value: IReviverValue): Division {
    const division = Generic_fromJSON(Division, value.data, Division.includedKeys);
    // division.type was renamed to division.industry in v3.0.0.
    assertObject(value.data);
    if ("type" in value.data) {
      division.industry = value.data.type as IndustryType;
    }
    return division;
  }

  static includedKeys = getKeyList(Division, { removedKeys: ["treeInitialized"] });
}

constructorsForReviver.Division = Division;
