/*new const knifeModels - Modele
new const knifeNames - Nazwy
new const knifeCosts - Koszt
new const knifeAccess - Dostęp (0 - dla każdego, ADMIN_LEVEL_* - dla danej flagi)

#define KNIFE_COUNT - ilość kos, jeśli masz 3, to KNIFE_COUNT = 3*/


#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <engine>
#include <vault>
#include <fun>
#include <ColorChat>
#include <nvault>

#define PLUGIN "Kup kose za farbki"
#define VERSION "2.1"


new const prefix[] = "[^x04 PB ^x01]"


#define FLAG_VIP ADMIN_LEVEL_H
#define MAX_PLAYERS 32
#define KNIFE_COUNT 14


#define ForArray(%1,%2) for(new %1 = 0; %1 < sizeof %2; %1++)
#define ForRange(%1,%2,%3) for(new %1 = %2; %1 <= %3; %1++)


native cod_get_user_coins(id);
native cod_set_user_coins(id, wartosc);


new userKnife[MAX_PLAYERS + 1],

	bool:userBought[KNIFE_COUNT][MAX_PLAYERS + 1],

	vaultHandle;


new const knifeCommands[][] =
{
	"/knife",
	"/kosy",
	"/noz"
};

new const knifeModels[][] =
{
	"models/v_knife.mdl",
	"models/pb/pbkosy/v_knifedaggerslau.mdl",
	"models/pb/pbkosy/v_knifesplintzer.mdl",

	"models/pb/pbkosy/v_knifedreamer.mdl",
	"models/pb/pbkosy/v_knifebutternorth.mdl",
	"models/pb/pbkosy/v_knife9dopler.mdl",

	"models/pb/pbkosy/v_knifekarlore.mdl",
	"models/pb/pbkosy/v_Kosa1.mdl",
	"models/pb/pbkosy/v_knifem9bayonet.mdl",

	"models/pb/pbkosy/v_knifemarblefade.mdl",
	"models/pb/pbkosy/v_knifeabyssal.mdl",
	"models/pb/pbkosy/v_knifeM9mgardient.mdl",

	"models/pb/pbkosy/v_knifered.mdl",
	"models/pb/pbkosy/v_knifebay33.mdl",
	"models/pb/pbkosy/v_knifeauto.mdl",

	"models/pb/pbkosy/v_knifegold.mdl",
	"models/pb/pbkosy_vip/v_testkvip.mdl"
};

new const knifeNames[][] =
{
	"Zwykly Noz",
	"Shadow Dagers | Slaughter",
	"Bagnet M9 | Splinter",

	"Karambit  | Blue Dreamer",
	"ButterFly | North",
	"Bayonet M9 | Dopler",

	//"Bayonet M9 | Fade",
	"Karambit | Dragon Lore",
	"Karambit | Marble Fade",

	"Bayonet M9 | Abyssal",
	"Bayonet M9 | Marble Gradient",
	"Karambit | Red Dreamer",

	"Bayonet M9 | Damascus Steel",
	"Gut Knife | Autotronic",
	"CrossFire | Noble Gold"
};

new const knifeCosts[] =
{
	0,
	0,
	30,

	50,
	80,
	100,

	//350,
	420,
	580,

	620,
	700,
	800,

	900,
	1000,
	7
};

new const knifeAccess[] =
{
	0,
	0,
	0,

	0,
	0,
	0,

	//0,
	0,
	0,

	0,
	0,
	0,

	0,
	FLAG_VIP,
	FLAG_VIP
};

public plugin_init()
{
	register_plugin(PLUGIN, VERSION, "K@MILOVVSKY");

	register_event("CurWeapon", "CurWeapon", "be", "1=1");

	registerCommands(knifeCommands, sizeof(knifeCommands), "chooseSkins");

	vaultHandle = nvault_open("Pb_Kosy");

	if(vaultHandle == INVALID_HANDLE)
	{
		set_fail_state("Nie mozna otworzyc pliku.");
	}
}


public plugin_precache()
{
	ForArray(i, knifeModels)
	{
		precache_model(knifeModels[i]);
	}
}

public client_authorized(id)
{
	Wczytaj(id);
	LoadDataKnife(id);
}

public client_disconnected(id)
{
	Zapisz(id);

	ForRange(i, 0, KNIFE_COUNT - 1)
	{
		userBought[i][id] = false;
	}
}

public plugin_end()
{
	nvault_close(vaultHandle);
}

public chooseSkins(index)
{
	new menuIndex = menu_create("Skiny dla:", "chooseSkins_handler"),
		menuCallbackVip = menu_makecallback("vipSkinsChosen"),
		menuCallbackVipNotAvailable = menu_makecallback("vipSkinsNotActive");

	menu_additem(menuIndex, "Graczy");
	menu_additem(menuIndex, "VIPow", "", 0, get_user_flags(index) & FLAG_VIP ? menuCallbackVip : menuCallbackVipNotAvailable);

	menu_display(index, menuIndex);

	return PLUGIN_HANDLED;
}

public chooseSkins_handler(index, menu, item)
{
	menu_destroy(menu);

	if(item == MENU_EXIT)
	{
		return PLUGIN_HANDLED;
	}

	chooseKnife(index, item);

	return PLUGIN_HANDLED;
}

public vipSkinsChosen(index, menu, item)
{
	return ITEM_ENABLED;
}

public vipSkinsNotActive(index, menu, item)
{
	return ITEM_DISABLED;
}

public chooseKnife(index, vipKnifes)
{
	new aktywna = menu_makecallback("aktywna_func"),
		nieaktywna = menu_makecallback("nieaktywna_func"),

		menuTitle[128],
		menuItem[128],
		menuIndex,
		menuData[4],

		bool:available,
		bool:costAvailable;

	formatex(menuTitle, charsmax(menuTitle), "\d==> \rDeagleShot.eu \d<==^n\wWybierz skin do \ykosy");

	menuIndex = menu_create(menuTitle, "knifeChosen");

	/*FREE*/
	if(vipKnifes)
	{
		menu_additem(menuIndex, "\wZwykly Noz", "0", 0, aktywna);
		menu_additem(menuIndex, "Shadow Dagers | Slaughter", "1", 0, aktywna);
	}

	ForRange(i, 2, KNIFE_COUNT - 1)
	{
		if(vipKnifes && !knifeAccess[i])
		{
			continue;
		}
		else if(!vipKnifes && knifeAccess[i])
		{
			continue;
		}

		if(userBought[i][index])
		{
			formatex(menuItem, charsmax(menuItem), "\w%s \d=>\yKupiono\d<=", knifeNames[i]);

			available = true;
		}
		else
		{
			costAvailable = bool:(cod_get_user_coins(index) >= knifeCosts[i]);

			formatex(menuItem, charsmax(menuItem), "\w%s \y[%s%s\r%i farbek \y]", knifeNames[i], costAvailable ? "\d" : "\y", costAvailable ? "koszt: " : "", knifeCosts[i]);

			available = costAvailable;
		}

		num_to_str(i, menuData, charsmax(menuData));

		menu_additem(menuIndex, menuItem, menuData, 0, available ? aktywna : nieaktywna);
	}

	menu_setprop(menuIndex, MPROP_BACKNAME, "Wstecz");
	menu_setprop(menuIndex, MPROP_NEXTNAME, "Dalej");
	menu_setprop(menuIndex, MPROP_EXITNAME, "Wyjdz");
	menu_display(index, menuIndex);
}

public knifeChosen(index, menu, item)
{
	new blank, menuData[6];

	menu_item_getinfo(menu, item, blank, menuData, charsmax(menuData), _, _, blank);

	item = str_to_num(menuData);

	menu_destroy(menu);

	if(!userBought[item][index] && cod_get_user_coins(index) >= knifeCosts[item])
	{
		/*
		if(knifeAccess[item])
		{
			if(!(get_user_flags(index) & knifeAccess[item]))
			{
				ColorChat(index, NORMAL, "%s Nie masz do tego dostepu.", prefix);

				return PLUGIN_HANDLED;
			}
		}
		*/

		cod_set_user_coins(index, cod_get_user_coins(index) - knifeCosts[item]);
		ColorChat(index, NORMAL, "%s Kupiles ^x04%s^x01 za^x03 %i ^x01farbek.", prefix, knifeNames[item], knifeCosts[item]);
		userBought[item][index] = true;
		Zapisz(index);
	}
	else if(!userBought[item][index])
	{
		return PLUGIN_HANDLED;
	}

	SetKnife(index, item);
	SaveDataKnife(index)

	return PLUGIN_HANDLED
}

public SetKnife(id, Knife)
{
	userKnife[id] = Knife;

	if(get_user_weapon(id) != CSW_KNIFE)
	{
		return PLUGIN_HANDLED;
	}

	entity_set_string(id, EV_SZ_viewmodel, knifeModels[Knife]);

	return PLUGIN_HANDLED;
}

public CurWeapon(id)
{
	if(!is_user_alive(id))
	{
		return PLUGIN_HANDLED;
	}

	SetKnife(id, userKnife[id])

	return PLUGIN_HANDLED;
}

SaveDataKnife(id)
{
	new steamIndex[32],
		vaultKey[64],
		vaultData[64];

	get_user_authid(id, steamIndex, charsmax(steamIndex));

	format(vaultKey, charsmax(vaultKey), "Knife_%s", steamIndex);
	format(vaultData, charsmax(vaultData), "%d", userKnife[id]);

	set_vaultdata(vaultKey, vaultData);
}

LoadDataKnife(id)
{
	new steamIndex[32],
		vaultKey[64];

	get_user_authid(id, steamIndex, charsmax(steamIndex));

	format(vaultKey, charsmax(vaultKey), "Knife_%s", steamIndex);

	userKnife[id] = get_vaultdata(vaultKey);
}

public aktywna_func(id, menu, item)
{
	return ITEM_ENABLED;
}

public nieaktywna_func(id, menu, item)
{
	return ITEM_DISABLED;
}

public client_putinserver(id)
{
	if(get_user_flags(id) & ADMIN_LEVEL_H || get_user_flags(id) & ADMIN_LEVEL_G)
	{
		return PLUGIN_HANDLED;
	}

	SetKnife(id, 0);

	return PLUGIN_HANDLED;
}

public Zapisz(id)
{
	new steamIndex[35];

	get_user_name(id, steamIndex, charsmax(steamIndex));

	new vaultKey[64],
		vaultData[256];

	format(vaultKey, charsmax(vaultKey), "%s-Skiny", steamIndex);

	ForRange(i, 0, KNIFE_COUNT - 1)
	{
		format(vaultData, charsmax(vaultData), "%s%d%s", vaultData, userBought[id], i == KNIFE_COUNT - 1 ? "" : "#");
	}

	nvault_set(vaultHandle, vaultKey, vaultData);

	return PLUGIN_CONTINUE;
}

public Wczytaj(id)
{
	new steamIndex[35],
		vaultKey[64],
		vaultData[256];

	get_user_name(id, steamIndex, charsmax(steamIndex));

	format(vaultKey, charsmax(vaultKey), "%s-Skiny", steamIndex);

	nvault_get(vaultHandle, vaultKey, vaultData, charsmax(vaultData));

	new vaultReadData[KNIFE_COUNT + 1][33];

	explode(vaultData, '#', vaultReadData, KNIFE_COUNT + 1, sizeof(vaultReadData));

	ForRange(i, 0, KNIFE_COUNT - 1)
	{
		userBought[i][id] = bool:str_to_num(vaultReadData[i]);
	}

	return PLUGIN_CONTINUE;
}

stock explode(const string[], const character, output[][], const maxs, const maxlen)
{
	new iDo = 0,
		len = strlen(string),
		oLen = 0;

	do
	{
		oLen += (1 + copyc(output[iDo++], maxlen, string[oLen], character))
	}

	while(oLen < len && iDo < maxs)
}

stock registerCommands(const array[][], arraySize, function[])
{
	#if !defined ForRange

		#define ForRange(%1,%2,%3) for(new %1 = %2; %1 <= %3; %1++)

	#endif

	new newCommand[33];

	ForRange(i, 0, arraySize - 1)
	{
		ForRange(j, 0, 1)
		{
			formatex(newCommand, charsmax(newCommand), "%s %s", !j ? "say" : "say_team", array[i]);
			register_clcmd(newCommand, function);
		}
	}
}