pi.nim

import db_sqlite
import tables
import strutils
import hashes
import math
import algorithm
import sets
import sequtils

type TTypeID* = string

proc open*(): TDbConn =
  result = open(connection="data/rub100-sqlite3-v1.db", user="trading", password="", database="data-dump")

const reactionsQuery = sql"SELECT map.schematicID, map.typeID, map.quantity, map.isInput, time.cycleTime from planetschematicstypemap as map, planetschematics as time WHERE time.schematicID = map.schematicID "

type
  TSchematicID = string
  TItem = object of TObject
    typeID: TTypeID
    amount: float
  TReaction = object of TObject
    inputs: TSet[TItem]
    output: TItem
    factories: float
  TReactionRow = object
    schematicID: TSchematicID
    typeID: TTypeID
    quantity: string
    isInput: string
    cycleTime: string
    
proc hash(x: TItem): THash = hash(x.typeID) !& hash(x.amount)
proc `*`(item: TItem, x: float): TItem =
  TItem(typeID: item.typeID, amount: item.amount * x)
  
proc merge(x: var TReaction, y: TReaction) =
  if x.output.typeID == y.output.typeID:
    x.factories += y.factories
    let tbl = indexBy(x.inputs, proc(input: TItem): TTypeID = input.typeID)

    for input in y.inputs:
      let id = input.typeID
      if hasKey(tbl, id):
        x.inputs.excl(tbl[id])
        x.inputs.incl(TItem(typeID: id, amount: tbl[id].amount + input.amount))
      else:
        x.inputs.incl(input)

  elif map(x.inputs, proc(i: TItem): TTypeID = i.typeID).contains(y.output.typeID):
    ## Replace the correspoding input of x with y.
    for input in x.inputs:
      if input.typeID == y.output.typeID:
        let factor = y.output.amount / input.amount
        x.inputs.excl(input)
        for inp in y.inputs: x.inputs.incl(inp*factor)
        x.factories += (factor * y.factories)
        return
  else:
    assert(false, "neither same output nor input to attach to")
    
proc merge(reactions: seq[TReaction]): TReaction =
  var
    tbl = initTable[TTypeID, TReaction]()
    foundOutput = false
    inputs = initSet[TTypeID]()
  for reaction in reactions:
    let id = reaction.output.typeID
    if hasKey(tbl, id):
      tbl.mget(id).merge(reaction)
    else:
      tbl[id] = reaction
    for input in reaction.inputs:
      inputs.incl(input.typeID)

  for reaction in reactions:
    if not inputs.contains(reaction.output.typeID):
       assert(foundOutput, "found two outputs")
       foundOutput = true
       result = reaction
       tbl.del(reaction.output.typeID)
    
  assert(foundOutput, "didn't find an output")
  var deletedSomething = true
  while len(tbl) > 0:
    if not deletedSomething:
      assert(false, "not converging")
    deletedSomething = false
    for input in result.inputs:
      let id = input.typeID
      if hasKey(tbl, id):
        merge(result, tbl[id])
        deletedSomething = true
        tbl.del(id)

# Unlikely to change anytime soon, so hardcoded. Increases the
# amounts in all reactions that are faster.
const maxCycleTime = "3600"

proc makeItem(row: TReactionRow): TItem =
  var amount: float
  if row.cycleTime != maxCycleTime:
    amount = (parseInt(row.quantity) * (parseInt(maxCycleTime)) / parseInt(row.cycleTime))
  else:
    amount = float(parseInt(row.quantity))
  result = TItem(typeID: row.typeID, amount: amount)

proc reactions(): TTable[TTypeID, TReaction] =
  result = initTable[TTypeID, TReaction]()
  let db = db.open()
  var grouping = initTable[TSchematicID, seq[TReactionRow]]()

  for row in db.fastRows(reactionsQuery):
    let id = TSchematicID(row[0])
    if not grouping.hasKey(id): grouping[id] = @[]
    grouping.mget(id).add(TReactionRow(schematicID: id, typeID: TTypeID(row[1]), quantity: row[2], isInput: row[3], cycleTime: row[4]))
    
  for rows in values(grouping):
    var
      inputs = initSet[TItem](16)
      output: TItem
    for row in rows:
      if row.isInput == "0":
        output = makeItem(row)
      else:
        inputs.incl(makeItem(row))
    result.add(output.typeID, TReaction(inputs: inputs, output: output, factories:1.0))

proc produceItem(reactions: TTable[TTypeID, TReaction], item: TItem): seq[TReaction] =
  # For each reaction, this creates all possible sets of edges leading to this item
  result = @[]
  if not(hasKey(reactions, item.typeID)): return
  # HOWTO:
  # create P3: [ <ways to produce P2>, <ways to produce P2>] including
  # P2 itself
  # ... and product that.
  var orderedInputs: seq[TItem] = @[]
  for item in reactions[item.typeID].inputs: orderedInputs.add(item)
  var possibilities: seq[seq[TReaction]] = @[]
  let
    current = reactions[item.typeID]
    factor = item.amount / current.output.amount
  for index, inp in orderedInputs:
    # Pseudo-reaction for only using the current factory
    possibilities.add(@[])
    # var inputSet = initSet[TItem]()
    # inputSet.incl(TItem(typeID: inp.TypeID, amount: inp.amount*factor))
    # possibilities[index].add(TReaction(inputs: inputSet, output: inp, factories: 0))
    
  for index, inpId in orderedInputs:
    for input in reactions[inpID.typeID].inputs:
      if reactions.hasKey(input.typeID):
        let factor = input.amount / current.output.amount
        var current = reactions[input.typeID]
        for recursiveInput in current.inputs:
          for path in produceItem(reactions, recursiveInput*factor):
            possibilities[index].add(path)

  for path in product(possibilities):
    var tmp = reactions[item.typeID]
    merge(tmp, merge(path))
    result.add(tmp)
    
import unittest
if isMainModule:
  let tbl = reactions()
  # suite "produce":
  #   test "P1 material":
  #     let inputs = toSet(@[TItem(typeID: TTypeID("2308"), amount: 3000)])
  #     check produceItem(tbl, TItem(typeID: TTypeID("2389"), amount: 20)) == @[TReaction(inputs: inputs, output: TItem(typeID: TTypeID("2389"), amount: 20), factories: 1)]
  echo(tbl)
  echo(repr(produceItem(tbl, TItem(typeID: TTypeID("2389"), amount: 20))))

planetschematics.csv

planetschematicstypemap.csv