import requests
from env import *

# https://wiki.alliedmods.net/Team_fortress_2_item_definition_indexes

def query_schema(start):
	url = f"http://api.steampowered.com/IEconItems_440/GetSchemaItems/v0001/?key={api_key}&start={start}&language={language}"
	response = requests.get(url)
	if response.status_code == 200:
		return response.json()
	else:
		raise Exception(f"Error fetching data: {response.status_code}")

def query_schema_items():
	start = 0
	all_items = []
	while True:
		data = query_schema(start)
		if 'result' in data and 'items' in data['result']:
			items = data['result']['items']
			if not items:
				break
			all_items.extend(items)
			if 'next' in data['result']:
				start = data['result']['next']
			else:
				break
		else:
			break
	return all_items

def fetch_my_items():
	url = f"http://api.steampowered.com/IEconItems_440/GetPlayerItems/v0001/?key={api_key}&SteamID={steam_id}"
	response = requests.get(url)
	if response.status_code == 200:
		return response.json()
	else:
		raise Exception(f"Error fetching data: {response.status_code}")

def save_to_file(data, filename):
	with open(filename, 'w') as file:
		file.write(data)

import json
import os
# Save the response to this url as a file called "my_items.json"

# Fetch items if not saved

if not os.path.exists("my_items.json"):
	# print("Fetching my items...")
	my_items = fetch_my_items()
	save_to_file(json.dumps(my_items, indent=4), "my_items.json")
else:
	# print("My items already fetched.")
	my_items = json.load(open("my_items.json"))

if not os.path.exists("schema_items.json"):
	# print("Fetching schema items...")
	# Save the schema items to a file called "schema_items.json"
	schema_items = query_schema_items()
	# Turn array into json object with "items" as key
	schema_items_json = {"items": schema_items}
	save_to_file(json.dumps(schema_items_json, indent=4), "schema_items.json")
else:
	# print("Schema items already fetched.")
	schema_items_json = json.load(open("schema_items.json"))

# Now filter both items to find only strange items
def is_strange_items(item):
	return item.get('quality', 0) == 11 # Strange quality

def is_strange_schema(item):
	return item.get('capabilities', {}).get('can_strangify', False)

# Filter to only weapons
def is_weapon(item):
	return item.get('item_slot', '') in ['primary', 'secondary', 'melee', 'pda', 'pda2', 'building']

# Filter out war paints
def is_war_paint(item):
	attributes = item.get('attributes', [])
	for attr in attributes:
		if attr.get('name', '') == 'set_item_texture_wear':
			return True
	return False

# Filter Slot Tokens
def is_slot_token(item):
	return "Slot Token" in item.get('name', '')

# Filter Default items
def is_default(item):
	return item.get('defindex') <= 30 or item.get('defindex') == 735 # Default items are not strange

# Filter Botkiller items
def is_botkiller(item):
	return "Botkiller" in item.get('name', '')

# Filter festive items
def is_festive(item):
	return "Festive" in item.get('name', '')

# Filter inelligible promo items
def is_promo(item):
	name = item.get('name', '')
	items = [
		"Promo", # Generic promo items
		"TTG", # Poker Night items (Telltale Games)
		"Quackenbirdt",
		"Black Rose",
		"Three-Rune Blade",
		"Fishcake",
		"Iron Curtain",
		"Sharpened Volcano Fragment",
		"Sun-on-a-Stick",
		"Nostromo Napalmer",
		"Sharp Dresser",
		"Maul",
		"Fortified Compound",
		"Robo-Sandvich",
		"Freedom Staff",
		"Ham Shank",
		"Prinny Machete",
		"Short Circuit",
		"Ap-Sap",
	]
	for item in items:
		if item in name:
			return True
	return False

def is_community(item):
	name = item.get('name', '')
	items = [
		"Gunboats",
		"Darwin's Danger Shield",
		"Ali Baba's Wee Booties",
		"Bootlegger",
		"Jumper", # Both jumper items
		"Horseless Headless Horseman's Headtaker",
		"Nessie's Nine Iron",
		"Scottish Handshake",
		"Cozy Camper",
		"Wanga Prick",
		"Postal Pummeler",
		"Unarmed Combat",
		"Conscientious Objector",
		"Bat Outta Hell",
		"Buffalo Steak Sandvich",
		"Eureka Effect",
		"Vita-Saw",
		"Tide Turner", # Why not valve?
		"Dragon's Fury", # Why not valve?
		"Thermal Thruster", # Why not valve?
		"Gas Passer", # Why not valve?
		"Hot Hand", # Why not valve?
		"Second Banana", # Why not valve?
	]
	for item in items:
		if item in name:
			return True
	return False

def is_bread_item(item):
	name = item.get('name', '')
	items = [
		"Bread Bite",
		"Self-Aware Beauty Mark",
		"Mutated Milk",
		"Snack Attack",
	]
	for item in items:
		if item in name:
			return True
	return False

def is_reskin(item):
	name = item.get('name', '')
	items = [
		"Shooting Star",
		"C.A.P.P.E.R",
		"Batsaber",
		"Giger Counter",
	]
	for item in items:
		if item in name:
			return True
	return False

def final_filter(item):
	name = item.get('name', '')
	items = [
		"Memory Maker", # Unobtainable item (as of now)
		"Saxxy", # Unobtainable item (as of now)
		"Deflector", # MVM specific item
		"Gloves of Running Urgently MvM", # MVM specific item
		"Golden Wrench", # Extremely rare item, not obtainable
		"Gold Frying Pan", # Extremely rare item, not obtainable
		"Necro Smasher", # Unobtainable item (as of now, strangifier is extremely rare)
	]
	for item in items:
		if item in name:
			return True
	return False

my_items = my_items.get('result', {}).get('items', [])
schema_items = schema_items_json.get('items', [])

strange_items = filter(is_strange_items, my_items)
strange_schema_items = filter(is_strange_schema, schema_items)
# Filter to only weapons, for brevity
strange_schema_items = filter(is_weapon, strange_schema_items)
# Filter out war paints
strange_schema_items = filter(lambda item: not is_war_paint(item), strange_schema_items)
# Filter out slot tokens
strange_schema_items = filter(lambda item: not is_slot_token(item), strange_schema_items)
# Filter out default items
strange_schema_items = filter(lambda item: not is_default(item), strange_schema_items)
# Filter out ineligible promo items
strange_schema_items = filter(lambda item: not is_promo(item), strange_schema_items)
# Filter out ineligible community items
strange_schema_items = filter(lambda item: not is_community(item), strange_schema_items)
# Filter out botkiller items (are strange, but undesirable)
strange_schema_items = filter(lambda item: not is_botkiller(item), strange_schema_items)
# Filter out festive items (are strange, but undesirable)
strange_schema_items = filter(lambda item: not is_festive(item), strange_schema_items)
# Filter out bread items (are strange, but undesirable)
#strange_schema_items = filter(lambda item: not is_bread_item(item), strange_schema_items)
# Filter out reskins (are strange, but generally expensive)
#strange_schema_items = filter(lambda item: not is_reskin(item), strange_schema_items)
# Filter out general ineligible items
strange_schema_items = filter(lambda item: not final_filter(item), strange_schema_items)


# Now remove items from schema that have the same defidex as items in my_items
for item in strange_items:
	defindex = item.get('defindex')
	strange_schema_items = [s_item for s_item in strange_schema_items if s_item.get('defindex') != defindex]

# Now print what's remaining, like defindex: name
for item in strange_schema_items:
	defindex = item.get('defindex')
	name = item.get('name', 'Unknown Item')
	common_name = item.get('item_name', name)  # Fallback to 'name' if 'item_name' is not present
	#print(f"Defindex: {defindex}, Name: {name}")
	print(f"{common_name} ({name}) [{defindex}]")