/*
 * $Id: mech.avail.c,v 1.1.1.1 2005/01/11 21:18:11 kstevens Exp $
 *
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *       All rights reserved
 *
 * Created: Fri Nov  8 19:53:17 1996 fingon
 * Last modified: Sat Jun  6 22:11:41 1998 fingon
 *
 */

/* Code to use the availability headers made by Nim */

#include <stdio.h>

#include "mech.h"
#include "mech.avail.h"
#include "coolmenu.h"
#include "mycool.h"
#include "p.template.h"
#include "p.mech.mechref_ident.h"

#define IsMech(i) ((i) < NUM_MECHA)
#define IsAero(i) ((i) >= NUM_MECHA && (i) < (NUM_MECHA + NUM_AEROS))

#define Table(id,fi) \
(IsMech(id) ? mech_availability[id].fi : \
 IsAero(id) ? aero_availability[id - NUM_MECHA].fi : 0)

static int find_score(int table, int id)
{
    switch (table) {
#undef Map
#define Map(a,b) case a: return Table(id,b); break;
	Map(FAC_FS, FS);
	Map(FAC_LC, LC);
	Map(FAC_DC, DC);
	Map(FAC_CC, CC);
	Map(FAC_FWL, FWL);
	Map(FAC_MISC, MISC);
	Map(FAC_MERC, MERC);
    case FAC_FC:
	return (find_score(FAC_FS, id) + find_score(FAC_LC, id)) / 2;
#undef Map
    }
    return 0;
}

/* Indeksointi:
   0 - NUM_MECHA-1                   = Mechs
   NUM_MECHA - NUM_MECHA+NUM_AEROS-1 = Aeros
 */

#define STACK_SIZE NUM_MECHA + NUM_AEROS

static void mech_list_maker(dbref player, int table, int types, int tons,
    int opt, int max, int mode, char *tbuf)
{
    int mech_stack[STACK_SIZE][2];
    int i, j, k;
    int tp = 0;
    int dif;
    int count = 0, ftons = 0, otons = tons;
    coolmenu *c = NULL;
    const char *d;

    bzero(mech_stack, sizeof(mech_stack));
    for (i = 0; i < STACK_SIZE; i++) {
	if (!(types & 1) && IsMech(i))
	    continue;
	if (!(types & 2) && IsAero(i))
	    continue;
	j = find_score(table, i);
	if (opt) {
	    if ((dif = abs(Table(i, tons) - opt)) > max && max)
		continue;
	    j = j * (100 - dif) * (100 - dif);
	} else
	    j = j * 10000;
	if (!j)
	    continue;
	tp += j;
	mech_stack[i][0] = j;
    }
    if (!tp) {
	if (!mode)
	    notify(player, "No 'mechs matching that criteria!");
	else
	    strcpy(tbuf, tprintf("#-1 ERROR: NO UNITS WITH FLAG %d FOUND",
		    types));
	return;
    }
    /* Ok.. We've made the table. Time to use it */
    while ((tons >= MAX(20, opt - max))) {
	i = Number(1, tp);
	for (j = 0; j < STACK_SIZE; j++) {
	    i -= mech_stack[j][0];
	    if (i <= 0)
		break;
	}
	if ((k = Table(j, tons)) > tons)
	    continue;
	mech_stack[j][1]++;
	tons -= k;
	count++;
	ftons += k;
    }
    /* We've a mech list. Time to show it :> */
    if (mode == 0) {
	addline();
	sim(tprintf("Mechs/Aeros/Whatever made for %s (%d tons)",
		side_names[table], otons), CM_ONE | CM_CENTER);
	addline();
	if (!count)
	    vsi("No mechs created? (Too low tonnage?)");
	else {
	    vsi(tprintf("%-4s %-10s %-20s %-6s %-s", "Tons", "Ref", "Name",
		    "Chance", "Count"));
	    for (i = 0; i < STACK_SIZE; i++)
		if (mech_stack[i][1]) {
		    d = find_mechname_by_mechref(Table(i, name));
		    vsi(tprintf("%4d %-10s %-20s %6.2f %d", Table(i, tons),
			    Table(i, name), d ? d : "Unknown",
			    (float) 100.0 * mech_stack[i][0] / tp,
			    mech_stack[i][1]));

		}
	    addline();
	    vsi(tprintf("Avg weight: %.2f Total tons: %d",
		    (float) ftons / count, ftons));
	}
	addline();
	ShowCoolMenu(player, c);
	KillCoolMenu(c);
    } else {
	*tbuf = 0;
	for (i = 0; i < STACK_SIZE; i++)
	    for (j = 0; j < mech_stack[i][1]; j++)
		sprintf(tbuf + strlen(tbuf), "%s ", Table(i, name));
	if (*tbuf)
	    tbuf[strlen(tbuf) - 1] = 0;
    }
}

void debug_makemechs(dbref player, void *data, char *buffer)
{
    char *args[7];
    int argc;
    int table;
    int tons;
    int opt = 0;
    int max = 0;
    int types = 0xff;

    argc = mech_parseattributes(buffer, args, 6);
    DOCHECK(argc < 2, "Insufficient arguments!");
    DOCHECK(argc > 5, "Too many arguments!");
    DOCHECK((table =
	    compare_array(side_names_short, args[0])) < 0,
	"Invalid faction name!");
    DOCHECK((tons = atoi(args[1])) < 20, "Invalid tonnage!");
    DOCHECK(tons > 4000, "Max of 4000 tons of mecha at once! Sowwy!");
    if (argc > 2) {
	DOCHECK(Readnum(types, args[2]), "Invalid type bitvector!");
	if (argc > 3) {
	    DOCHECK((opt = atoi(args[3])) < 20, "Invalid optTonnage!");
	    if (argc > 4)
		DOCHECK((max =
			atoi(args[4])) < 5, "Invalid MaxDifference!");
	}
    }
    mech_list_maker(player, table, types, tons, opt, max, 0, NULL);
}

#define FUNCHECK(a,b) \
if (a) { safe_tprintf_str(buff, bufc, b); return; }

void fun_btmakemechs(char *buff, char **bufc, dbref player, dbref cause, char *fargs[], int nfargs, char *cargs[], int ncargs)
{
    /* fargs[0] = faction 
       fargs[1] = numtons
       fargs[2] = types
       fargs[3] = opttons
       fargs[4] = maxvar 
     */
    int table;
    int tons;
    int opt = 0;
    int max = 0;
    char buf[LBUF_SIZE];
    int types = 0xff;

    FUNCHECK(nfargs < 2, "#-1 Insufficient arguments!");
    FUNCHECK(nfargs > 5, "#-1 Too many arguments!");
    FUNCHECK((table =
	    compare_array(side_names_short, fargs[0])) < 0,
	"#-1 Invalid faction name!");
    FUNCHECK((tons = atoi(fargs[1])) < 20, "#-1 Invalid tonnage!");
    FUNCHECK(tons > 4000, "#-1 Max of 4000 tons of mecha at once! Sowwy!");
    if (nfargs > 2) {
	FUNCHECK(Readnum(types, fargs[2]), "#-1 Invalid type bitvector!");
	if (nfargs > 3) {
	    FUNCHECK((opt =
		    atoi(fargs[3])) < 20, "#-1 Invalid optTonnage!");
	    if (nfargs > 4)
		FUNCHECK((max =
			atoi(fargs[4])) < 5, "#-1 Invalid MaxDifference!");
	}
    }
    mech_list_maker(player, table, types, tons, opt, max, 1, buf);
    safe_tprintf_str(buff, bufc, "%s", buf);
}