from discord.ext import tasks
import discord
import traceback
import asyncio
import aiohttp
import os

import numpy as np
import math
from collections import Counter
import re
from typing import List, Dict, Any, Optional, Union

class AnyFieldIsNotFilled(Exception):
	pass

#ai slooop for ai slooop

EPSILON = 1e-6

PERMISSION_LEVEL_MAP = {
    'DONT_HAVE': 0, 'NONE': 0, None: 0,
    'FREE': 1,
    'VIP': 2,
    'MODERATOR': 3,
    'ADMIN': 4, 'ROOT': 4
}
MAX_PERMISSION_LEVEL = 4

class KamazAI_v1_3:
	def __init__(self, report_list):
		self.k_neighbors = 5
		self.weights = {
			'steam_identity': 0.35,
			'reason': 0.15,
			'permissions': 0.10,
			'derived_stats': 0.30,
			'server': 0.10
		}
		self.historical_reports: List[Dict[str, Any]] = []
		self.report_actions: Dict[int, List[str]] = {}
		self.derived_stats: Optional[Dict[str, Dict[str, float]]] = None
		self.derived_fields = [
			'a_kd', 'a_kpm', 'a_dpm',
			'r_kd', 'r_kpm', 'r_dpm',
			'kd_diff',
			'a_session_min', 'r_session_min'
		]

		self.initialize(report_list)

	# ------------------------------------------------------------------
	# Семантическое сравнение причин
	# ------------------------------------------------------------------
	@staticmethod
	def _reason_similarity(reason1: str, reason2: str) -> float:
		"""Jaccard-сходство по множествам слов (регистронезависимо)."""
		# Извлекаем буквенно-цифровые токены
		tokens1 = set(re.findall(r'\w+', reason1.lower()))
		tokens2 = set(re.findall(r'\w+', reason2.lower()))
		if not tokens1 or not tokens2:
			return 1.0 if reason1 == reason2 else 0.0
		intersection = tokens1 & tokens2
		union = tokens1 | tokens2
		return len(intersection) / len(union)

	# ------------------------------------------------------------------
	# Вспомогательные методы
	# ------------------------------------------------------------------
	@staticmethod
	def _parse_permission_level(value: Union[str, int, None]) -> int:
		if isinstance(value, str):
			return PERMISSION_LEVEL_MAP.get(value.upper(), 0)
		if value is None:
			return 0
		try:
			return int(value)
		except (ValueError, TypeError):
			return 0

	@staticmethod
	def _compute_derived_features(report: Dict[str, Any]) -> Dict[str, float]:
		a_min = max((report['a_seconds'] if report['a_seconds'] else 0) / 60.0, EPSILON)
		r_min = max((report['r_seconds'] if report['r_seconds'] else 0) / 60.0, EPSILON)
		a_kd = (report['a_kills'] if report['a_kills'] else 0) / max((report['a_deads'] if report['a_deads'] else 0), EPSILON)
		r_kd = (report['r_kills'] if report['r_kills'] else 0) / max((report['r_deads'] if report['r_deads'] else 0), EPSILON)
		kd_diff = r_kd - a_kd
		return {
			'a_kd': a_kd,
			'a_kpm': (report['a_kills'] if report['a_kills'] else 0) / a_min,
			'a_dpm': (report['a_deads'] if report['a_deads'] else 0) / a_min,
			'r_kd': r_kd,
			'r_kpm': (report['r_kills'] if report['r_kills'] else 0) / r_min,
			'r_dpm': (report['r_deads'] if report['r_deads'] else 0) / r_min,
			'kd_diff': kd_diff,
			'a_session_min': a_min,
			'r_session_min': r_min
		}

	def _compute_derived_stats(self) -> Dict[str, Dict[str, float]]:
		stats = {f: {'min': float('inf'), 'max': float('-inf')} for f in self.derived_fields}
		for r in self.historical_reports:
			feats = self._compute_derived_features(r)
			for f in self.derived_fields:
				val = feats[f]
				if val < stats[f]['min']:
					stats[f]['min'] = val
				if val > stats[f]['max']:
					stats[f]['max'] = val
		return stats

	def _normalize_derived(self, feats: Dict[str, float]) -> Dict[str, float]:
		norm = {}
		for f in self.derived_fields:
			min_val = self.derived_stats[f]['min']
			max_val = self.derived_stats[f]['max']
			if max_val - min_val < EPSILON:
				norm[f] = 0.0
			else:
				norm[f] = (feats[f] - min_val) / (max_val - min_val)
		return norm

	def _similarity(self, r1: Dict[str, Any], r2: Dict[str, Any]) -> float:
		score = 0.0

		# 1. Совпадение связки игроков
		#if r1['a_steam2'] == r2['a_steam2'] and r1['r_steam2'] == r2['r_steam2']:
		#	identity_score = 1.0
		#elif r1['a_steam2'] == r2['a_steam2'] or r1['r_steam2'] == r2['r_steam2']:
		#	identity_score = 0.5
		#else:
		#	identity_score = 0.0
		#score += self.weights['steam_identity'] * identity_score

		# 2. Причина – теперь семантически, через Jaccard
		reason_score = self._reason_similarity(r1['reasons'], r2['reasons'])
		score += self.weights['reason'] * reason_score

		# 3. Права
		a_lvl1 = self._parse_permission_level(r1['a_permition'])
		a_lvl2 = self._parse_permission_level(r2['a_permition'])
		r_lvl1 = self._parse_permission_level(r1['r_permition'])
		r_lvl2 = self._parse_permission_level(r2['r_permition'])
		dist_a = abs(a_lvl1 - a_lvl2) / MAX_PERMISSION_LEVEL
		dist_r = abs(r_lvl1 - r_lvl2) / MAX_PERMISSION_LEVEL
		perm_sim = 1.0 - (dist_a + dist_r) / 2.0
		score += self.weights['permissions'] * perm_sim

		# 4. Производные признаки
		f1 = self._normalize_derived(self._compute_derived_features(r1))
		f2 = self._normalize_derived(self._compute_derived_features(r2))
		dist_sq = sum((f1[f] - f2[f]) ** 2 for f in self.derived_fields)
		eucl_dist = math.sqrt(dist_sq / len(self.derived_fields))
		derived_sim = 1.0 - min(eucl_dist, 1.0)
		score += self.weights['derived_stats'] * derived_sim

		# 5. Сервер
		#srv_score = 1.0 if r1['srv'] == r2['srv'] else 0.0
		#score += self.weights['server'] * srv_score

		return score

	# ------------------------------------------------------------------
	# Публичные асинхронные методы
	# ------------------------------------------------------------------
	def initialize(self, reports: List[Dict[str, Any]]) -> None:
		self.historical_reports = []
		self.report_actions.clear()

		for report in reports:
			#if report.get("type", "IN_GAME") != "IN_GAME":
			#	continue
			self.historical_reports.append(report)

			try:
				self.report_actions[report["id"]] = report["actions"]
			except:
				print("Cannot build action", report)
			
		self.derived_stats = self._compute_derived_stats()

	async def predict(self, new_report: Dict[str, Any]) -> Dict[str, Any]:
		if not self.historical_reports or self.derived_stats is None:
			raise RuntimeError("System not initialized. Call 'await initialize()' first.")

		similarities = []
		for hist in self.historical_reports:
			sim = self._similarity(new_report, hist)
			similarities.append((hist['id'], sim))

		similarities.sort(key=lambda x: x[1], reverse=True)
		top_k = similarities[:self.k_neighbors]

		action_counter = Counter()
		similar_ids = []
		for rid, sim in top_k:
			if sim > 0:
				similar_ids.append(rid)
				if rid in self.report_actions:
					for act in self.report_actions[rid]:
						action_counter[act] += 1

		total = sum(action_counter.values())
		suggestions = []
		if total > 0:
			for action, count in action_counter.most_common():
				suggestions.append({
					'action': action,
					'confidence': round(count / total, 4)
				})
		else:
			suggestions.append({'action': 'none', 'confidence': 1.0})

		return {
			'suggestions': suggestions,
			'similar_reports': similar_ids
		}

	async def reload_actions(self, new_actions: List[Dict[str, Any]]) -> None:
		for act in new_actions:
			rid = act['report_id']
			self.report_actions.setdefault(rid, []).append(act['action'])

#depricated
class KamazAI_v1_2:
	"""
	Асинхронная система рекомендации действий модератора на основе исторических жалоб.
	Использование:
		system = ReportDecisionSystem()
		await system.initialize(reports, actions)
		result = await system.predict(new_report)
	"""

	def __init__(self, report_list):
		self.k_neighbors = 5
		self.weights = {
			'steam_identity': 0.35,
			'reason': 0.15,
			'permissions': 0.10,
			'derived_stats': 0.30,
			'server': 0.10
		}
		self.historical_reports: List[Dict[str, Any]] = []
		self.report_actions: Dict[int, List[str]] = {}
		self.derived_stats: Optional[Dict[str, Dict[str, float]]] = None
		self.derived_fields = [
			'a_kd', 'a_kpm', 'a_dpm',
			'r_kd', 'r_kpm', 'r_dpm',
			'kd_diff',
			'a_session_min', 'r_session_min'
		]
		self.initialize(report_list)

	# ---------- Вспомогательные методы ----------
	@staticmethod
	def _compute_derived_features(report: Dict[str, Any]) -> Dict[str, float]:
		"""Вычисляет производные признаки для одной записи."""
		try:
			a_min = max(report['a_seconds'] / 60.0, EPSILON)
		except:
			a_min = 1

		try:	
			r_min = max(report['r_seconds'] / 60.0, EPSILON)
		except:
			r_min = 1

		try:
			a_kd = report['a_kills'] / max(report['a_deads'], EPSILON)
		except:
			a_kd = 1

		try:	
			r_kd = report['r_kills'] / max(report['r_deads'], EPSILON)
		except:
			r_kd = 1

		kd_diff = r_kd - a_kd
		try:
			return {
				'a_kd': a_kd,
				'a_kpm': report['a_kills'] / a_min,
				'a_dpm': report['a_deads'] / a_min,
				'r_kd': r_kd,
				'r_kpm': report['r_kills'] / r_min,
				'r_dpm': report['r_deads'] / r_min,
				'kd_diff': kd_diff,
				'a_session_min': a_min,
				'r_session_min': r_min
			}
		except:
			raise AnyFieldIsNotFilled

	def _compute_derived_stats(self) -> Dict[str, Dict[str, float]]:
		"""Вычисляет min/max для всех производных признаков по историческим данным."""
		stats = {f: {'min': float('inf'), 'max': float('-inf')} for f in self.derived_fields}
		for r in self.historical_reports:
			try:
				feats = self._compute_derived_features(r)
				for f in self.derived_fields:
					val = feats[f]
					if val < stats[f]['min']:
						stats[f]['min'] = val
					if val > stats[f]['max']:
						stats[f]['max'] = val
			except AnyFieldIsNotFilled:
				continue
		return stats

	def _normalize_derived(self, feats: Dict[str, float]) -> Dict[str, float]:
		"""Нормализует производные признаки в [0,1]."""
		norm = {}
		for f in self.derived_fields:
			min_val = self.derived_stats[f]['min']
			max_val = self.derived_stats[f]['max']
			if max_val - min_val < EPSILON:
				norm[f] = 0.0
			else:
				norm[f] = (feats[f] - min_val) / (max_val - min_val)
		return norm

	def _similarity(self, r1: Dict[str, Any], r2: Dict[str, Any]) -> float:
		"""Вычисляет взвешенное сходство (0..1) между двумя отчётами."""
		score = 0.0

		# 1. Совпадение пары Steam
		#if r1['a_steam2'] == r2['a_steam2'] and r1['r_steam2'] == r2['r_steam2']:
		#	identity_score = 1.0
		#elif r1['a_steam2'] == r2['a_steam2'] or r1['r_steam2'] == r2['r_steam2']:
		#	identity_score = 0.5
		#else:
		#	identity_score = 0.0
		#score += self.weights['steam_identity'] * identity_score

		# 2. Причина
		reason_score = 1.0 if r1['reasons'] == r2['reasons'] else 0.0
		score += self.weights['reason'] * reason_score

		# 3. Права
		perm_score = 0.0
		if r1['a_permition'] == r2['a_permition']:
			perm_score += 0.5
		if r1['r_permition'] == r2['r_permition']:
			perm_score += 0.5
		score += self.weights['permissions'] * perm_score

		# 4. Производные признаки
		f1 = self._normalize_derived(self._compute_derived_features(r1))
		f2 = self._normalize_derived(self._compute_derived_features(r2))
		dist_sq = sum((f1[f] - f2[f]) ** 2 for f in self.derived_fields)
		eucl_dist = math.sqrt(dist_sq / len(self.derived_fields))
		derived_sim = 1.0 - min(eucl_dist, 1.0)
		score += self.weights['derived_stats'] * derived_sim

		# 5. Сервер
		#srv_score = 1.0 if r1['srv'] == r2['srv'] else 0.0
		#score += self.weights['server'] * srv_score

		return score

	# ---------- Публичные асинхронные методы ----------
	def initialize(self, reports: List[Dict[str, Any]]) -> None:
		"""
		Загружает исторические данные и вычисляет нормализацию.
		:param reports: список записей из user_reports
		:param actions: список записей из user_reports_action
		"""
		self.historical_reports = reports
		self.report_actions.clear()

		for report in self.historical_reports:
			try:
				self.report_actions[report["id"]] = report["actions"]
			except:
				print("Cannot build action", report)

		self.derived_stats = self._compute_derived_stats()

	async def predict(self, new_report: Dict[str, Any]) -> Dict[str, Any]:
		"""
		Возвращает рекомендации для новой жалобы.
		:param new_report: словарь с полями нового репорта (без id)
		:return: словарь с ключами 'suggestions' и 'similar_reports'
		"""
		if not self.historical_reports or self.derived_stats is None:
			raise RuntimeError("System not initialized. Call 'await initialize()' first.")

		# Расчёт сходства со всеми историческими записями
		similarities = []
		for hist in self.historical_reports:
			try:
				sim = self._similarity(new_report, hist)
				similarities.append((hist['id'], sim))
			except AnyFieldIsNotFilled:
				pass

		similarities.sort(key=lambda x: x[1], reverse=True)
		top_k = similarities[:self.k_neighbors]

		# Сбор действий
		action_counter = Counter()
		similar_ids = []
		for rid, sim in top_k:
			if sim > 0:
				similar_ids.append(rid)
				if rid in self.report_actions:
					for act in self.report_actions[rid]:
						action_counter[act] += 1

		total = sum(action_counter.values())
		suggestions = []
		if total > 0:
			for action, count in action_counter.most_common():
				suggestions.append({
					'action': action,
					'confidence': round(count / total, 4)
				})
		else:
			suggestions.append({'action': 'none', 'confidence': 1.0})

		return {
			'suggestions': suggestions,
			'similar_reports': similar_ids
		}

	async def reload_actions(self, new_actions: List[Dict[str, Any]]) -> None:
		"""Обновить только действия, не пересчитывая нормализацию (если поступили новые решения)."""
		for act in new_actions:
			rid = act['report_id']
			self.report_actions.setdefault(rid, []).append(act['action'])

#depricated
class KamazAI_v1_1:
	WEIGHTS = {
		'steam_identity': 0.4,

		'reason': 0.2,
		'permissions': 0.1,
		'numerics': 0.2,

		'server': 0.1
	}
	K_NEIGHBORS = 5

	'''
	{
	"id":2,

	"a_nickname":"Роботяга",
	"a_permition":"DONT_HAVE",
	"a_kills":6,
	"a_deads":5,
	"a_seconds":392,

	"r_nickname":"zombiskell",
	"r_permition":"DONT_HAVE",
	"r_kills":10,
	"r_deads":10,
	"r_seconds":2022,

	"reasons":"Читы",
	"utime":1717502378,
	"srv":"srv9",
	"online":18,
	"type":"IN_GAME",
	"actions":["inspect"],
	"serverName":"Норильск 2019",
	"a_steam":{
		"steam3":"[U:1:1338527208]",
		"steam2":"STEAM_0:0:669263604",
		"steam64":"76561199298792936",
		"community_url":"https://steamcommunity.com/profiles/76561199298792936",
		"account_id":1338527208
		},
	"r_steam":{
		"steam3":"[U:1:1554861952]",
		"steam2":"STEAM_0:0:777430976",
		"steam64":"76561199515127680",
		"community_url":"https://steamcommunity.com/profiles/76561199515127680",
		"account_id":1554861952
		}
	}
	'''

	def __init__(self, reports_list):
		print("Reports list size: ", len(reports_list))
		self.historical_reports = reports_list
		self.report_actions = {}
		for report in reports_list:
			try:
				self.report_actions[report["id"]] = report["actions"]
			except:
				print("Cannot build action", report)

		self.numeric_stats = self.normalize_numerics(reports_list)

	'''
	def init_data(reports: list, actions: list):
		"""Загрузка данных при старте или через специальный endpoint."""
		global historical_reports, report_actions
		historical_reports = reports
		report_actions.clear()
		for act in actions:
			rid = act['report_id']
			report_actions.setdefault(rid, []).append(act['action'])
	'''
    
	def normalize_numerics(self, reports):
		"""Вычисляет min/max для всех числовых полей (обучающая выборка)."""
		fields = ['a_kills', 'a_deads', 'a_seconds', 'r_kills', 'r_deads', 'r_seconds', 'online']
		stats = {}
		for f in fields:
			values = [r[f] for r in reports if r[f] is not None]
			stats[f] = {'min': min(values), 'max': max(values)}
		return stats
	
	async def similarity(self, report1, report2, num_stats):
		"""Возвращает взвешенное сходство (0..1)."""
		score = 0.0

		# 1. Совпадение пары Steam-аккаунтов
		if False:
			identity_score = 0.0
			if report1['a_steam2'] == report2['a_steam2'] and report1['r_steam2'] == report2['r_steam2']:
				identity_score = 1.0
			elif report1['a_steam2'] == report2['a_steam2'] or report1['r_steam2'] == report2['r_steam2']:
				identity_score = 0.5
			score += self.WEIGHTS['steam_identity'] * identity_score

		# 2. Причина (точное совпадение)
		reason_score = 1.0 if report1['reasons'] == report2['reasons'] else 0.0
		score += self.WEIGHTS['reason'] * reason_score

		# 3. Права
		perm_score = 0.0
		if report1['a_permition'] == report2['a_permition']:
			perm_score += 0.5
		if report1['r_permition'] == report2['r_permition']:
			perm_score += 0.5
		score += self.WEIGHTS['permissions'] * perm_score


		# 4. Числовые поля (нормированное евклидово расстояние -> сходство) #todo kd
		num_fields = ['a_kills', 'a_deads', 'a_seconds', 'r_kills', 'r_deads', 'r_seconds', 'online']
		dist_sq = 0.0
		for f in num_fields:
			min_val = num_stats[f]['min']
			max_val = num_stats[f]['max']
			if max_val == min_val:
				norm_diff = 0.0
			else:
				try:
					norm_diff = (report1[f] - report2[f]) / (max_val - min_val)
				except:
					norm_diff = 0.0
			dist_sq += norm_diff ** 2
		eucl_dist = np.sqrt(dist_sq / len(num_fields))
		# Превращаем расстояние в сходство (1 - нормализованное расстояние)
		num_similarity = 1.0 - min(eucl_dist, 1.0)
		score += self.WEIGHTS['numerics'] * num_similarity

		# 5. Сервер
		if False:
			srv_score = 1.0 if report1['srv'] == report2['srv'] else 0.0
			score += self.WEIGHTS['server'] * srv_score

		return [score, 
		  {
			  "reason_score": reason_score, 
			  "perm_score": perm_score, 
			  "num_similarity": num_similarity}]
	
	async def predict(self, new_report):
		# Вычисляем сходство со всеми историческими заявками
		similarities = []
		for hist in self.historical_reports:
			s_container = await self.similarity(new_report, hist, self.numeric_stats)
			similarities.append((hist['id'], s_container[0], s_container[1]))

		# Сортируем по убыванию сходства
		similarities.sort(key=lambda x: x[1], reverse=True)
		top_k = similarities[:self.K_NEIGHBORS]
		#print(top_k)

		# Собираем все действия, назначенные на эти заявки
		action_counter = Counter()
		similar_report_ids = []
		for rid, sim, score_rate in top_k:
			#print(rid, sim)
			if sim > 0:  # можно задать порог, чтобы отсечь шум
				similar_report_ids.append(rid)
				if rid in self.report_actions:
					for act in self.report_actions[rid]:
						action_counter[act] += 1

		total = sum(action_counter.values())
		suggestions = []
		if total > 0:
			for action, count in action_counter.most_common():
				suggestions.append({
					'action': action,
					'confidence': round(count / total, 4)
				})
		else:
			# Если ни одного похожего – предложение "inspect" по умолчанию
			suggestions.append({'action': 'none', 'confidence': 1.0})

		return {
			'suggestions': suggestions,
			'similar_reports': similar_report_ids
		}

class Extension:
	core = None
	actions = {
		'ban': ["забанить игрока", 4],
		'inspect': ["проверить профиль стима и решить что делать дальше", 1],
		'kick': ["кикнуть игрока", 2],
		'ban30': ["легкий бан на 30 минут", 3],
		'ban120': ["бан на пару часов", 3],
		'noreason': ["не вводить причину", -1],
		'author_kick': ["кикнуть автора репорта", 2],
		'mute': ["замьютить игрока", 1],
		'unban': ["разбанить игрока если тот в бане, ебанутое решение", -1],
		'author_inspect': ['глянуть профиль автора репорта', 1],
		'none': ['ничего не делать, лучше не лезть', 0]
	}

	def __init__(self, core):
		self.core = core
		self.kamazai = None
		self.reports_list = []

	async def task(self, timeout = 15):
		if os.getenv('BACKEND_URL') and os.getenv("BACKEND_SECRETKEY"):
			pass
		else:
			print("Cannot init kamazAI, BACKEND_URL or BACKEND_SECRETKEY is missing in env")
			return

		await self.core.wait_until_ready()
		while True:
			await self.updater()
			await asyncio.sleep(timeout)

	async def updater(self):
		try:
			if self.kamazai == None:
				print("Sync report list")
				async with aiohttp.ClientSession(cookies={
					"secretkey":os.getenv("BACKEND_SECRETKEY")}) as session:
					async with session.get(f"{os.getenv('BACKEND_URL')}/api/discord/report/s", ssl = False) as response:
						self.reports_list = await response.json()
						self.kamazai = KamazAI_v1(self.reports_list)
						print("KamazAI Enabled")
		except:
			traceback.print_exc()

	async def __call__(self, message: discord.Message = None):
		if self.kamazai == None:
			print("call kamazAi but he is not init")
			return await message.reply(content=f'KamazAI не иницилизирован')
		
		try:
			report_id = message.embeds[0].color.value
			#print("Found report id", report_id)
		except:
			return await message.reply(content=f'KamazAI не может получить индификатор репорта')

		async with aiohttp.ClientSession(cookies={
			"secretkey":os.getenv("BACKEND_SECRETKEY")}) as session:
			async with session.get(f"{os.getenv('BACKEND_URL')}/api/discord/report/{report_id}", ssl = False) as response:
				report = await response.json()

		result = await self.kamazai.predict(report)
		suggestions = result.get("suggestions", [{"confidence":1, "action": "none"}])
		embed: discord.Embed = discord.Embed(description="Решил что с этим репортом надо сделать")
		embed.set_author(name="Камаз AI", icon_url="https://media.istockphoto.com/id/532124854/ru/%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BD%D0%B0%D1%8F/%D0%B5%D0%B2%D1%80%D0%B5%D0%B9%D1%81%D0%BA%D0%B8%D0%B9-%D1%80%D0%BE%D0%B1%D0%BE%D1%82-%D0%BF%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0%D0%B6%D0%B0.jpg?s=170667a&w=0&k=20&c=3n1zIaQ0zd36upFONeofKPVioEf5JfFnDs6gShydAvw=")
		for ss in suggestions:
			if ss["action"] == "noreason":
				continue

			embed.add_field(
				name=f'{round(ss["confidence"] * 100)}%', 
				value=f'{self.actions.get(ss["action"], [ss["action"], 100])[0]}', 
				inline=False)
		
		same_reports = []
		same_reports.append(str(report_id))
		for s in result.get("similar_reports", []):
			same_reports.append(str(s))
		embed.set_footer(text=",".join(same_reports))
		response = await message.reply(embed=embed)
		try:
			await response.add_reaction('👍')
			await response.add_reaction('👎')
		except:
			pass

		return response

		#self.reports_list.append(report)
		#self.kamazai = KamazAI(self.reports_list)

if __name__ == "__main__":
	async def run():
		print("run")
		from json import load
		with open("/Users/gsd/Downloads/reports.json", "r", encoding="utf8") as report_list:
			kamazAi = KamazAI_v1_3(load(report_list))

		perm_list = []
		for r in kamazAi.historical_reports:
			if r['a_permition'] not in perm_list:
				perm_list.append(r['a_permition'])
			if r['r_permition'] not in perm_list:
				perm_list.append(r['r_permition'])
		print(perm_list)

		test_report1 = {"id":23059,"a_nickname":"серийный чувак","a_permition":"DONT_HAVE","a_kills":29,"a_deads":38,"a_seconds":3237,"r_nickname":"Корабль Бомж 1","r_permition":"DONT_HAVE","r_kills":44,"r_deads":31,"r_seconds":3598,"reasons":"Читы","utime":1780842262,"srv":"srv9","online":18,"type":"IN_GAME","actions":[],"serverName":"Норильск 2019","a_steam":{"steam3":"[U:1:1675616295]","steam2":"STEAM_0:1:837808147","steam64":"76561199635882023","community_url":"https://steamcommunity.com/profiles/76561199635882023","account_id":1675616295},"r_steam":{"steam3":"[U:1:1546493291]","steam2":"STEAM_0:1:773246645","steam64":"76561199506759019","community_url":"https://steamcommunity.com/profiles/76561199506759019","account_id":1546493291}}
		test_report2 = {"id":23048,"a_nickname":"Евгений Задротов","a_permition":"FREE","a_kills":63,"a_deads":68,"a_seconds":5031,"r_nickname":"Kapusta_KvSH","r_permition":"VIP","r_kills":11,"r_deads":2,"r_seconds":436,"reasons":"VIP абуз","utime":1780837315,"srv":"srv5","online":21,"type":"IN_GAME","actions":[],"serverName":"Завод Ultimate","a_steam":{"steam3":"[U:1:1623272121]","steam2":"STEAM_0:1:811636060","steam64":"76561199583537849","community_url":"https://steamcommunity.com/profiles/76561199583537849","account_id":1623272121},"r_steam":{"steam3":"[U:1:196806785]","steam2":"STEAM_0:1:98403392","steam64":"76561198157072513","community_url":"https://steamcommunity.com/profiles/76561198157072513","account_id":196806785}}
		
		print(test_report1)
		print(await kamazAi.predict(test_report1))
		print()
		print(test_report2)
		print(await kamazAi.predict(test_report2))
	import asyncio
	asyncio.run(run())