export function htmlPrintPpCmdsDiff(l : PpCmds, old : PpCmds) : string {
  _(patterns).each(pattern => {
    l = pattern(l)
    old = pattern(old)
  })
  if (!ppCmdsSameShape(l, old)) {
    return markDifferent(
      _.reduce(
        l,
        (acc : string, p : PpCmdType) => {
          return acc + htmlPrintPpCmd(p)
        },
        ''
      )
    )
  }
  const z = _.zip(l, old)
  return _.reduce(
    z,
    (acc : string, [p, oldP] : [PpCmdType, PpCmdType]) => {
      return acc + htmlPrintPpCmdDiff(p, oldP)
    },
    ''
  )
}

export function addHiddenChildTotals(values) {
		let childValues = values;
		// Add the Totals Together
		let childEntryTotalAgg =
			reduce(filter(childValues, (z: any) => { return z.TYPE === 'Total'; })
				, (sum = 0, z: any) => {
					return sum + Number(z.AMOUNT);
				}, 0);
		// Get the Sub Category child entires
		values = filter(childValues, (z: any) => { return z.TYPE !== 'Total'; });
		if (values.length == 0) {
			// No Deducated Entries
			values = childValues;
		} else {

			// Get the SubCategory child entry Values that aren't totals
			let subValueTotals = reduce(filter(childValues, (z: any) => { return z.TYPE != 'Total'; })
				, (sum = 0, z: any) => {
					return sum + Number(z.AMOUNT);
				}, 0);
			// If The Subcategory Entry Values dont add up to the Subcategory Total Value
			// Insert a hidden arc on the circle
			if (subValueTotals !== childEntryTotalAgg) {
				values.push({
					AMOUNT: childEntryTotalAgg - subValueTotals,
					CATEGORY: "Flexible Earmark",
					FUNDING_CATEGORY: "Emergency Reserve",
					TYPE: 'Hidden'
				})
			}
		}
		return values;
}

 return _.map(outcomeTradeRowsByPeriod, (trades: Array<MarketPriceHistoryRow>, startTimestamp): Candlestick => {
   // TODO remove this partialCandlestick stuff and just return
   // a Candlestick after the temporary Candlestick.tokenVolume
   // is removed (see note on Candlestick.tokenVolume).
   const partialCandlestick: Pick<Candlestick, Exclude<keyof Candlestick, "tokenVolume">> = { // this Pick/Exclude stuff just allows us to set the Candlestick.tokenVolume later, but in a typesafe way that prevents typos.
     startTimestamp: parseInt(startTimestamp, 10),
     start: _.minBy(trades, "timestamp")!.price.toString(),
     end: _.maxBy(trades, "timestamp")!.price.toString(),
     min: _.minBy(trades, "price")!.price.toString(),
     max: _.maxBy(trades, "price")!.price.toString(),
     volume: _.reduce(trades, (totalVolume: BigNumber, tradeRow: MarketPriceHistoryRow) => totalVolume.plus(volumeForTrade({
       marketMinPrice: marketsRow.minPrice,
       marketMaxPrice: marketsRow.maxPrice,
       numCreatorTokens: tradeRow.numCreatorTokens,
       numCreatorShares: tradeRow.numCreatorShares,
       numFillerTokens: tradeRow.numFillerTokens,
       numFillerShares: tradeRow.numFillerShares,
     })), ZERO).toString(),
     shareVolume: _.reduce(trades, (totalShareVolume: BigNumber, tradeRow: MarketPriceHistoryRow) => totalShareVolume.plus(tradeRow.amount), ZERO).toString(), // the business definition of shareVolume should be the same as used with markets/outcomes.shareVolume (which currently is just summation of trades.amount)
   };
   return {
     tokenVolume: partialCandlestick.shareVolume, // tokenVolume is temporary, see note on Candlestick.tokenVolume
     ...partialCandlestick,
   };
 });

export async function getReportingFees(db: Knex, augur: Augur, params: t.TypeOf<typeof ReportingFeesParams>): Promise<FeeDetails> {
  const currentUniverse = await getUniverse(db, params.universe);
  const participantEthFees: Array<ParticipantEthFee> = await getParticipantEthFees(db, augur, params.reporter, params.universe);
  const participationTokenEthFees: Array<ParticipationTokenEthFee> = await getParticipationTokenEthFees(db, augur, params.reporter, params.universe);
  const result: FormattedMarketInfo = await getMarketsReportingParticipants(db, params.reporter, currentUniverse, participantEthFees);
  const repStakeResults = await getStakedRepResults(db, params.reporter, params.universe, result.nonforkedMarkets);
  const unclaimedParticipantEthFees = _.reduce(participantEthFees, (acc, cur) => acc.plus(cur.fork ? 0 : cur.ethFees), ZERO);
  const unclaimedForkEthFees = _.reduce(participantEthFees, (acc, cur) => acc.plus(cur.fork ? cur.ethFees : 0), ZERO);
  const unclaimedParticipationTokenEthFees = _.reduce(participationTokenEthFees, (acc, cur) => acc.plus(cur.ethFees), ZERO);
  const redeemableFeeWindows = _.map(participationTokenEthFees, "feeWindow");
  const participationTokenRepStaked = _.reduce(participationTokenEthFees, (acc, cur) => acc.plus(cur.participationTokens), ZERO);
  const unclaimedRepStaked = repStakeResults.fees.unclaimedRepStaked.plus(participationTokenRepStaked);
  return {
    total: {
      unclaimedParticipationTokenEthFees: unclaimedParticipationTokenEthFees.toFixed(0, BigNumber.ROUND_DOWN),
      participationTokenRepStaked: participationTokenRepStaked.toFixed(0, BigNumber.ROUND_DOWN),
      unclaimedEth: unclaimedParticipantEthFees.plus(unclaimedParticipationTokenEthFees).toFixed(0, BigNumber.ROUND_DOWN),
      unclaimedRepStaked: unclaimedRepStaked.toFixed(0, BigNumber.ROUND_DOWN),
      unclaimedRepEarned: repStakeResults.fees.unclaimedRepEarned.toFixed(0, BigNumber.ROUND_DOWN),
      lostRep: repStakeResults.fees.lostRep.toFixed(0, BigNumber.ROUND_DOWN),
      unclaimedForkEth: unclaimedForkEthFees.toFixed(0, BigNumber.ROUND_DOWN),
      unclaimedForkRepStaked: repStakeResults.fees.unclaimedForkRepStaked.toFixed(0, BigNumber.ROUND_DOWN),
    },
    feeWindows: redeemableFeeWindows.sort(),
    forkedMarket: result.forkedMarket,
    nonforkedMarkets: repStakeResults.nonforkedMarkets,
  };
}

function countBackgroundGoals<T>(goals : IGoals<T>) : number {
  return _.reduce(
    goals.bgGoals,
    (acc, elt) => acc + elt.before.length + elt.after.length,
    0
  )
}

export async function fetchOncoKbAnnotatedGenes(client: OncoKbAPI = oncokbClient): Promise<{[entrezGeneId:number]:boolean}>
{
    return _.reduce(await client.genesGetUsingGET({}), (map:{[entrezGeneId:number]:boolean}, next:OncoKbGene)=>{
            map[next.entrezGeneId] = true;
            return map;
        }, {});
}

const itemsFromInvoiceToStockable = (items) => {
  return _.reduce(items, (prev, cur: StockItemModel) => {
    prev[cur.sku] = prev[cur.sku] || 0;
    prev[cur.sku] += cur.quantity;
    return prev;
  }, {});
};

 let saveLog = results => {
     let application: ApplicationModel = results[0],
         basicinfo: ApplicationBasicinfoModel = results[1];
     if (isLog === 'true') {
         LogModel.setConnection(connection);
         let after = _.reduce(admissionInfo.getDocument(),
             (result, value) => (result.push(value), result), []);
         return LogModel.save({
             id: UUID.raw(),
             moduleid,
             module,
             opttype: '1',
             nodeid: user.nodeId,
             nodetype: user.nodeType,
             studentid: id,
             cscid: application.cscId,
             passportname: basicinfo.fullname,
             after: after.join('/'),
             before: null,
             columnen: null,
             columnch: null,
             tableen: 'ASMS_ADMISSION',
             tablech: '录取信息表',
             createby: user.userId,
             created: moment().toDate()
         });
     }
 }

  private groupKeyForLineItems(lineItems: ILineItem[]): string {
    const sortedLineItems = sortBy(lineItems, 'product.id');

    return reduce(sortedLineItems, (key, lineItem) => {
      return key + this.groupKeyForLineItem(lineItem);
    }, '');
  }

  let baseData = _.map(data, item => {
    return _.reduce(report.columns, (prev, cur: any) => {
      if(!cur.checked && !cur.always) { return prev; }
      const value = _.get(item, cur.key, '');

      prev[cur.name] = value;

      if(_.isNull(value)) {
        prev[cur.name] = '';
      }

      if(_.includes(['Purchase Time', 'Last Sold', 'Start Date', 'End Date'], cur.name)) {
        if(!value) {
          prev[cur.name] = 'Never';
        } else {
          prev[cur.name] = dateFunctions.format(new Date(value), 'YYYY-MM-DD hh:mm A');
        }
      }

      if(cur.name === 'Purchase Method') {
        prev[cur.name] = settings.invoiceMethodDisplay(value);
      }

      return prev;
    }, {});
  });