cry-vetzdravila 1.0.0

package/src/register/helper/poisciZivalskoVrsto.ts

@@ -0,0 +1,100 @@
+/**
+ * Iskanje živalskih vrst
+ *
+ * Funkcije za iskanje in ujemanje živalskih vrst iz registra.
+ * Uporablja _match regex iz skupneEntitete.vrsteZivali.
+ */
+
+import { ZivalskeVrste } from "../types/ZivalskeVrste";
+
+/**
+ * Rezultat iskanja živalske vrste
+ */
+export interface RezultatIskanja {
+	/** Najdena vrsta (ključ iz ZivalskeVrste) */
+	vrsta: string;
+	/** Nadrejena vrsta, če obstaja */
+	nadrejenaVrsta: string | null;
+}
+
+/**
+ * Poišče nadrejeno živalsko vrsto za podano vrsto
+ * Primer: "krave v laktaciji" → "govedo", "kokoši nesnice" → "perutnina"
+ *
+ * Uporablja _match regex iz ZivalskeVrste
+ */
+export function findNadrejenaVrsta(vrsta: string): string | null {
+	const vrstaLower = vrsta.toLowerCase();
+
+	for (const [key, vrstaDef] of Object.entries(ZivalskeVrste)) {
+		if (!vrstaDef?._match) continue;
+
+		if (vrstaDef._match.test(vrstaLower)) {
+			// Če ima vrsta nadrejeno vrsto (vrsta !== key), vrni nadrejeno
+			if (typeof vrstaDef.vrsta === "string" && vrstaDef.vrsta.toLowerCase() !== key.toLowerCase()) {
+				return vrstaDef.vrsta;
+			}
+			// Vrsta je že osnovni ključ - ni nadrejene
+			return null;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Poišče ustrezno živalsko vrsto za podani niz
+ *
+ * @param za - Niz za iskanje (npr. "psi", "krave v laktaciji", "kokoši nesnice")
+ * @returns Rezultat z najdeno vrsto in nadrejeno vrsto (če obstaja)
+ */
+export function poisciZivalskoVrsto(za: string): RezultatIskanja | null {
+	if (!za || typeof za !== "string") return null;
+
+	const zaLower = za.toLowerCase().trim();
+	if (zaLower === "") return null;
+
+	// 1. Poskusi najti točno ujemanje po ključu
+	for (const [key, vrstaDef] of Object.entries(ZivalskeVrste)) {
+		if (key.toLowerCase() === zaLower) {
+			return {
+				vrsta: key,
+				nadrejenaVrsta: findNadrejenaVrsta(key),
+			};
+		}
+	}
+
+	// 2. Poskusi z _match regex iz ZivalskeVrste
+	for (const [key, vrstaDef] of Object.entries(ZivalskeVrste)) {
+		if (!vrstaDef?._match) continue;
+
+		if (vrstaDef._match.test(zaLower)) {
+			return {
+				vrsta: key,
+				nadrejenaVrsta: findNadrejenaVrsta(key),
+			};
+		}
+
+		// Poskusi tudi po lastnosti vrsta
+		if (typeof vrstaDef.vrsta === "string" && vrstaDef.vrsta.toLowerCase() === zaLower) {
+			return {
+				vrsta: key,
+				nadrejenaVrsta: findNadrejenaVrsta(key),
+			};
+		}
+	}
+
+	// 3. Ni ujemanja - vrni izvorni niz kot vrsto
+	return {
+		vrsta: za,
+		nadrejenaVrsta: null,
+	};
+}
+
+/**
+ * Normalizacija imena živalske vrste
+ */
+export function normalizeVrsta(vrsta: string): string {
+	// Odstrani # znak in odvečne presledke
+	return vrsta.replace(/#/g, "").trim().toLowerCase();
+}

package/src/register/helper/razcleniNaziv.ts

@@ -0,0 +1,105 @@
+import { RazclenjeniNaziv, normalizirajNaziv, KOLICINA_PATTERN, TEZA_PATTERN, DOZA_PATTERN } from "./normalizirajNaziv";
+import { poisciZivalskoVrsto } from "./poisciZivalskoVrsto";
+import { ZivalskeVrste } from "../types/ZivalskeVrste";
+
+// Seznam veljavnih ključev živalskih vrst (male črke)
+const VELJAVNE_VRSTE = new Set(Object.keys(ZivalskeVrste).map(k => k.toLowerCase()));
+
+/**
+ * Razčleni normaliziran naziv zdravila na sestavne dele
+ *
+ * @param naziv - Izvorni naziv zdravila
+ * @returns Objekt z razčlenjenimi sestavinami
+ */
+
+// Vzorec za prepoznavanje količine v obliki á/a + številka sredi niza
+const KOLICINA_A_PATTERN = /(?<![a-zA-ZčšžćđČŠŽĆĐ])[aá]\s*(\d+)/i;
+
+export function razcleniNaziv(naziv: string): RazclenjeniNaziv {
+	const izvorni_naziv = naziv;
+
+	// Pred normalizacijo poiščemo količino v obliki á/a + številka
+	let kolicinaIzSrediNiza: string | null = null;
+	const aMatch = KOLICINA_A_PATTERN.exec(naziv.toLowerCase());
+	if (aMatch) {
+		kolicinaIzSrediNiza = aMatch[1]; // Samo številka
+	}
+
+	const normaliziran_naziv = normalizirajNaziv(naziv);
+
+	// Razdelimo normaliziran naziv na besede
+	const deli = normaliziran_naziv.split(/\s+/).filter(d => d.length > 0);
+
+	let teza: string | null = null;
+	let kolicina: string | null = null;
+	const doze: string[] = [];
+	const besede: string[] = [];
+
+	// Preverimo, ali je zadnji del količina
+	if (deli.length > 0) {
+		const zadnji = deli[deli.length - 1];
+		if (KOLICINA_PATTERN.test(zadnji)) {
+			kolicina = zadnji;
+			deli.pop();
+		}
+	}
+
+	// Če ni količine na koncu, uporabi količino iz á/a vzorca sredi niza
+	if (!kolicina && kolicinaIzSrediNiza) {
+		kolicina = kolicinaIzSrediNiza;
+		// Odstrani to številko iz delov (normalizacija jo je pretvorila v samostojno številko)
+		const idx = deli.indexOf(kolicinaIzSrediNiza);
+		if (idx !== -1) {
+			deli.splice(idx, 1);
+		}
+	}
+
+	// Pregledamo preostale dele
+	for (const del of deli) {
+		// Preverimo, ali je teža
+		if (TEZA_PATTERN.test(del)) {
+			teza = del;
+			continue;
+		}
+
+		// Preverimo, ali je doza
+		if (DOZA_PATTERN.test(del)) {
+			doze.push(del);
+			continue;
+		}
+
+		// Sicer je beseda
+		besede.push(del);
+	}
+
+	// Filtriraj vezniške besede "in" in "za"
+	const filtriraneBesede = besede.filter(b => b !== "in" && b !== "za");
+
+	// Poišči živalske vrste med besedami
+	const zivalskeVrste: string[] = [];
+	const preostaleBesede: string[] = [];
+
+	for (const beseda of filtriraneBesede) {
+		const rezultat = poisciZivalskoVrsto(beseda);
+		// Preverimo, ali je rezultat veljavna živalska vrsta (ne izvorni niz)
+		if (rezultat && VELJAVNE_VRSTE.has(rezultat.vrsta.toLowerCase())) {
+			// Našli smo prepoznano živalsko vrsto
+			if (!zivalskeVrste.includes(rezultat.vrsta)) {
+				zivalskeVrste.push(rezultat.vrsta);
+			}
+		} else {
+			// Ni živalska vrsta, ohrani med besedami
+			preostaleBesede.push(beseda);
+		}
+	}
+
+	return {
+		izvorni_naziv,
+		normaliziran_naziv,
+		teza,
+		kolicina,
+		doze,
+		besede: preostaleBesede,
+		zivalskeVrste
+	};
+}

package/src/register/helper/testNormalizacije.ts

@@ -0,0 +1,89 @@
+/**
+ * Test normalizacije
+ *
+ * Generira datoteki z izvornimi in normaliziranimi imeni zdravil.
+ */
+
+import { parseRegister } from "../parseRegister";
+import { normalizirajNaziv } from "./normalizirajNaziv";
+import { razcleniNaziv } from "./razcleniNaziv";
+import { poisciZivalskoVrsto } from "./poisciZivalskoVrsto";
+import testData from "../../test/zdravila.json";
+import { writeFileSync } from "fs";
+
+/** Seznam znanih živalskih vrst za ujemanje */
+const ZIVALSKE_VRSTE_BESEDE = [
+	"pse", "psi", "psa", "pes",
+	"mačke", "mačka", "mačko", "mačk",
+	"govedo", "krave", "krava", "telice", "teleta", "telet", "biki", "voli",
+	"konje", "konj", "konja", "konji", "žrebeta", "osle", "osli",
+	"prašiče", "prašič", "prašiči", "pujske", "pujski", "svinje",
+	"ovce", "ovca", "jagnjeta", "jagnjet", "ovni",
+	"koze", "koza", "kozle", "kozliče",
+	"kunce", "kuncev", "kunci",
+	"perutnina", "piščance", "piščanci", "kokoši", "purane", "purani", "race", "gosi",
+	"ribe", "postrvi",
+	"čebele", "čebel",
+];
+
+
+
+interface ZdraviloTest {
+	naziv: string;
+	skupine: string[];
+}
+
+async function main() {
+	console.log("Generiranje normalizacijskih datotek...\n");
+
+	// 1. Register zdravil
+	console.log("Nalagam register...");
+	const register = parseRegister("./data/register.xlsx");
+	console.log(`Register naložen: ${register.steviloZdravil} zdravil\n`);
+
+	// Generiraj zdravila-register-norm.txt
+	const registerLines: string[] = [];
+	const registerImena = register.zdravila.map((z) => z.ime).sort((a, b) => a.localeCompare(b, "sl"));
+
+	for (const ime of registerImena) {
+		const razclenjeno = razcleniNaziv(ime);
+		registerLines.push(` `);
+		registerLines.push(`- ${ime}`);
+		registerLines.push(`> ${razclenjeno.normaliziran_naziv}`);
+		const deli: string[] = [];
+		if (razclenjeno.besede) deli.push(`${razclenjeno.besede}`);
+		if (razclenjeno.doze.length > 0) deli.push(`[ ${razclenjeno.doze.join(", ")} ]`);
+		if (razclenjeno.teza) deli.push(`${razclenjeno.teza}`);
+		if (razclenjeno.zivalskeVrste.length>0) deli.push(`[ ${razclenjeno.zivalskeVrste} ]`);
+		if (razclenjeno.kolicina) deli.push(`${razclenjeno.kolicina}`);
+		registerLines.push(`= ${deli.join("  -  ")}`);
+	}
+	
+	writeFileSync("./data/zdravila-register-norm.txt", registerLines.join("\n"), "utf-8");
+	console.log(`Zapisano: data/zdravila-register-norm.txt (${registerImena.length} zdravil)`);
+	
+	// 2. Vhodna zdravila iz zdravila.json
+	const vhodZdravila = (testData as ZdraviloTest[]).map((z) => z.naziv).sort((a, b) => a.localeCompare(b, "sl"));
+	
+	const vhodLines: string[] = [];
+	for (const naziv of vhodZdravila) {
+		const razclenjeno = razcleniNaziv(naziv);
+		vhodLines.push(` `);
+		vhodLines.push(`- ${naziv}`);
+		vhodLines.push(`> ${razclenjeno.normaliziran_naziv}`);
+		const deli: string[] = [];
+		if (razclenjeno.besede) deli.push(`${razclenjeno.besede}`);
+		if (razclenjeno.doze.length > 0) deli.push(`[ ${razclenjeno.doze.join(", ")} ]`);
+		if (razclenjeno.teza) deli.push(`${razclenjeno.teza}`);
+		if (razclenjeno.zivalskeVrste.length>0) deli.push(`[ ${razclenjeno.zivalskeVrste} ]`);
+		if (razclenjeno.kolicina) deli.push(`${razclenjeno.kolicina}`);
+		vhodLines.push(`= ${deli.join("  -  ")}`);
+	}
+
+	writeFileSync("./data/zdravila-vhod-norm.txt", vhodLines.join("\n"), "utf-8");
+	console.log(`Zapisano: data/zdravila-vhod-norm.txt (${vhodZdravila.length} zdravil)`);
+
+	console.log("\nKončano!");
+}
+
+main();

package/src/register/helper/testPodobnosti.ts

@@ -0,0 +1,238 @@
+/**
+ * Test podobnosti - preverja, ali oceniPodobnost pravilno prepozna zdravila
+ *
+ * Za vsako zdravilo iz registra preveri, ali se pri iskanju samega sebe
+ * zdravilo pojavi na prvem mestu.
+ */
+
+import { razcleniNaziv } from "./razcleniNaziv";
+import { oceniPodobnost, type UtemeljitevOcene } from "./oceniPodobnost";
+import { seznamZdravil } from "../../generated/seznamZdravil"
+import type { RazclenjeniNaziv } from "./normalizirajNaziv";
+
+interface RazclembaZdravila {
+	ime: string;
+	razclemba: RazclenjeniNaziv;
+}
+
+// Predpripravi razčlembe vseh zdravil iz registra
+function pripraviRazclembeRegistra(): RazclembaZdravila[] {
+	return seznamZdravil.map((zdravilo) => ({
+		ime: zdravilo.ime,
+		razclemba: razcleniNaziv(zdravilo.ime),
+	}));
+}
+
+interface RezultatIskanja {
+	ime: string;
+	ocena: number;
+}
+
+// Poišči najboljša ujemanja za dano razčlembo
+function poisciNajboljsa(
+	razclembaVhoda: RazclenjeniNaziv,
+	razclembeRegistra: RazclembaZdravila[]
+): RezultatIskanja[] {
+	const rezultati: RezultatIskanja[] = [];
+
+	for (const { ime, razclemba } of razclembeRegistra) {
+		const utemeljitev = oceniPodobnost(razclembaVhoda, razclemba);
+		rezultati.push({ ime, ocena: utemeljitev.ocena });
+	}
+
+	// Sortiraj po oceni padajoče
+	rezultati.sort((a, b) => b.ocena - a.ocena);
+
+	return rezultati;
+}
+
+interface Statistika {
+	// Natanko en zadetek z najvišjo oceno
+	enZadetek: number;
+	// Več zadetkov z enako najvišjo oceno, prvi je pravi
+	vecPrviPravi: number;
+	// Več zadetkov z enako najvišjo oceno, pravi je med njimi (a ni prvi)
+	vecPraviMedNjimi: number;
+	// Pravi ni med zadetki z najvišjo oceno
+	niZadetka: number;
+	// Skupaj
+	skupaj: number;
+}
+
+interface NajdeniZadetek {
+	ime: string;
+	razclemba: RazclenjeniNaziv;
+	utemeljitev: UtemeljitevOcene;
+}
+
+interface VecPraviMedNjimiPrimer {
+	iskaniNaziv: string;
+	iskanaRazclemba: RazclenjeniNaziv;
+	najdeniDoVkljucnoPravega: NajdeniZadetek[];
+}
+
+function izpisiRazclembo(razclemba: RazclenjeniNaziv): string {
+	const deli: string[] = [];
+	if (razclemba.besede.length > 0) deli.push(`besede: [${razclemba.besede.join(", ")}]`);
+	if (razclemba.doze.length > 0) deli.push(`doze: [${razclemba.doze.join(", ")}]`);
+	if (razclemba.teza) deli.push(`teza: ${razclemba.teza}`);
+	if (razclemba.kolicina) deli.push(`kolicina: ${razclemba.kolicina}`);
+	if (razclemba.zivalskeVrste.length > 0) deli.push(`zivalskeVrste: [${razclemba.zivalskeVrste.join(", ")}]`);
+	return deli.join(", ");
+}
+
+function izpisiUtemeljitev(u: UtemeljitevOcene): string {
+	const deli: string[] = [];
+	deli.push(`ocena: ${u.ocena}`);
+	if (u.ocenaPrvihBesed > 0) deli.push(`prveBesede: ${u.ocenaPrvihBesed}`);
+	if (u.ocenaVelikosti > 0) deli.push(`velikost: ${u.ocenaVelikosti}`);
+	if (u.ocenaDoze > 0) deli.push(`doze: ${u.ocenaDoze}`);
+	if (u.ocenaTeze > 0) deli.push(`teza: ${u.ocenaTeze}`);
+	if (u.ocenaKolicine > 0) deli.push(`kolicina: ${u.ocenaKolicine}`);
+	if (u.ocenaZivalskihVrst > 0) deli.push(`zivalske: ${u.ocenaZivalskihVrst}`);
+	if (u.ocenaBesed > 0) deli.push(`besede: ${u.ocenaBesed}`);
+	if (u.steviloBesed !== 0) deli.push(`štBesed: ${u.steviloBesed}`);
+	return deli.join(", ");
+}
+
+async function main() {
+	console.log("═══════════════════════════════════════════════════════════════");
+	console.log("              TEST PODOBNOSTI");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+
+	console.log("Pripravljam razčlembe registra...");
+	const razclembeRegistra = pripraviRazclembeRegistra();
+	console.log(`Pripravljenih ${razclembeRegistra.length} razčlemb.\n`);
+
+	const statistika: Statistika = {
+		enZadetek: 0,
+		vecPrviPravi: 0,
+		vecPraviMedNjimi: 0,
+		niZadetka: 0,
+		skupaj: 0,
+	};
+
+	const napake: string[] = [];
+	const vecPraviMedNjimiPrimeri: VecPraviMedNjimiPrimer[] = [];
+
+	console.log("Testiram podobnosti...\n");
+
+	for (const { ime, razclemba } of razclembeRegistra) {
+		statistika.skupaj++;
+
+		// Poišči najboljša ujemanja
+		const rezultati = poisciNajboljsa(razclemba, razclembeRegistra);
+
+		if (rezultati.length === 0) {
+			statistika.niZadetka++;
+			napake.push(`[NI ZADETKA] ${ime}`);
+			continue;
+		}
+
+		const najvisjaOcena = rezultati[0].ocena;
+
+		// Poišči vse z najvišjo oceno
+		const najboljsi = rezultati.filter((r) => r.ocena === najvisjaOcena);
+
+		// Preveri, ali je pravi med najboljšimi
+		const praviIndex = najboljsi.findIndex((r) => r.ime === ime);
+
+		if (najboljsi.length === 1) {
+			// Natanko en zadetek
+			if (najboljsi[0].ime === ime) {
+				statistika.enZadetek++;
+			} else {
+				statistika.niZadetka++;
+				napake.push(`[NAPAČEN ZADETEK] ${ime} -> ${najboljsi[0].ime}`);
+			}
+		} else if (praviIndex === 0) {
+			// Več zadetkov, prvi je pravi
+			statistika.vecPrviPravi++;
+		} else if (praviIndex > 0) {
+			// Več zadetkov, pravi je med njimi (a ni prvi)
+			// Preveri, ali imajo vsi zadetki pred pravim enak normaliziran naziv (podvojeno zdravilo)
+			const normaliziranNaziv = razclemba.normaliziran_naziv;
+			const vsiEnaki = najboljsi.slice(0, praviIndex + 1).every((r) => {
+				const rRazclemba = razclembeRegistra.find((reg) => reg.ime === r.ime)!.razclemba;
+				return rRazclemba.normaliziran_naziv === normaliziranNaziv;
+			});
+
+			if (vsiEnaki) {
+				// Podvojeno zdravilo - štejemo kot en zadetek
+				statistika.enZadetek++;
+			} else {
+				statistika.vecPraviMedNjimi++;
+				// Zberi vse zadetke do vključno pravega
+				const najdeniDoVkljucnoPravega: NajdeniZadetek[] = [];
+				for (let i = 0; i <= praviIndex; i++) {
+					const najdeniIme = najboljsi[i].ime;
+					const najdenaRazclemba = razclembeRegistra.find((r) => r.ime === najdeniIme)!.razclemba;
+					const utemeljitev = oceniPodobnost(razclemba, najdenaRazclemba);
+					najdeniDoVkljucnoPravega.push({ ime: najdeniIme, razclemba: najdenaRazclemba, utemeljitev });
+				}
+				vecPraviMedNjimiPrimeri.push({ iskaniNaziv: ime, iskanaRazclemba: razclemba, najdeniDoVkljucnoPravega });
+			}
+		} else {
+			// Pravi ni med zadetki z najvišjo oceno
+			statistika.niZadetka++;
+			napake.push(`[NI MED NAJBOLJŠIMI] ${ime} (najboljši: ${najboljsi.slice(0, 3).map((r) => r.ime).join(", ")})`);
+		}
+	}
+
+	// Izpis statistike
+	console.log("═══════════════════════════════════════════════════════════════");
+	console.log("                         STATISTIKA");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+
+	const pct = (n: number) => ((n / statistika.skupaj) * 100).toFixed(1);
+
+	console.log(`Skupaj zdravil:                    ${statistika.skupaj}`);
+	console.log(`Natanko en zadetek:                ${statistika.enZadetek} (${pct(statistika.enZadetek)}%)`);
+	console.log(`Več zadetkov, prvi je pravi:       ${statistika.vecPrviPravi} (${pct(statistika.vecPrviPravi)}%)`);
+	console.log(`Več zadetkov, pravi je med njimi:  ${statistika.vecPraviMedNjimi} (${pct(statistika.vecPraviMedNjimi)}%)`);
+	console.log(`Ni zadetka / napačen zadetek:      ${statistika.niZadetka} (${pct(statistika.niZadetka)}%)`);
+
+	const uspesnost = statistika.enZadetek + statistika.vecPrviPravi + statistika.vecPraviMedNjimi;
+	console.log(`\nUspešnost (pravi med zadetki):     ${uspesnost} (${pct(uspesnost)}%)`);
+
+	if (napake.length > 0) {
+		console.log("\n═══════════════════════════════════════════════════════════════");
+		console.log("                         NAPAKE");
+		console.log("═══════════════════════════════════════════════════════════════\n");
+		for (const napaka of napake.slice(0, 20)) {
+			console.log(napaka);
+		}
+		if (napake.length > 20) {
+			console.log(`... in še ${napake.length - 20} napak`);
+		}
+	}
+
+	if (vecPraviMedNjimiPrimeri.length > 0) {
+		console.log("\n═══════════════════════════════════════════════════════════════");
+		console.log("            VEČ ZADETKOV, PRAVI JE MED NJIMI");
+		console.log("═══════════════════════════════════════════════════════════════");
+		for (const primer of vecPraviMedNjimiPrimeri) {
+			console.log("");
+			console.log(primer.iskaniNaziv);
+			console.log("=".repeat(primer.iskaniNaziv.length));
+			console.log(`    iskana razčlemba: ${izpisiRazclembo(primer.iskanaRazclemba)}`);
+			console.log("");
+			for (const zadetek of primer.najdeniDoVkljucnoPravega) {
+				console.log(zadetek.ime);
+				console.log(`    razčlemba: ${izpisiRazclembo(zadetek.razclemba)}`);
+				console.log(`    utemeljitev: ${izpisiUtemeljitev(zadetek.utemeljitev)}`);
+			}
+		}
+	}
+
+	console.log("\n═══════════════════════════════════════════════════════════════");
+	console.log("                         KONČANO");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+}
+
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error("Napaka:", e);
+		process.exit(1);
+	});
+}

package/src/register/helper/testVakcin.ts

@@ -0,0 +1,103 @@
+/**
+ * Pregled vakcin v registru zdravil
+ *
+ * Izpiše vse vakcine iz registra in proti katerim boleznim ščitijo.
+ */
+
+import { seznamZdravil } from "../../generated/seznamZdravil";
+import { zdraviloJeVakcinaZa, jeVakcina } from "../zdraviloJeVakcinaZa";
+
+function main() {
+	console.log("═══════════════════════════════════════════════════════════════");
+	console.log("              PREGLED VAKCIN V REGISTRU ZDRAVIL");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+
+	// Poišči vse vakcine
+	const vakcine = seznamZdravil.filter((z) => jeVakcina(z));
+
+	console.log(`Skupaj vakcin v registru: ${vakcine.length}\n`);
+
+	// Razvrsti po boleznih
+	const poBoleznih: Record<string, { ime: string; atcKoda: string }[]> = {};
+
+	for (const zdravilo of vakcine) {
+		const bolezni = zdraviloJeVakcinaZa(zdravilo);
+		if (bolezni) {
+			for (const bolezen of bolezni) {
+				if (!poBoleznih[bolezen]) {
+					poBoleznih[bolezen] = [];
+				}
+				poBoleznih[bolezen].push({
+					ime: zdravilo.ime,
+					atcKoda: zdravilo.atcKoda || "-",
+				});
+			}
+		}
+	}
+
+	// Izpis po boleznih (sortirano po številu vakcin)
+	const sortiraneBolezni = Object.keys(poBoleznih).sort(
+		(a, b) => poBoleznih[b].length - poBoleznih[a].length
+	);
+
+	for (const bolezen of sortiraneBolezni) {
+		const seznam = poBoleznih[bolezen];
+		console.log("───────────────────────────────────────────────────────────────");
+		console.log(`${bolezen.toUpperCase()} (${seznam.length})`);
+		console.log("───────────────────────────────────────────────────────────────\n");
+
+		for (const z of seznam) {
+			console.log(`  [${z.atcKoda}] ${z.ime}`);
+		}
+		console.log();
+	}
+
+	// Statistika
+	console.log("═══════════════════════════════════════════════════════════════");
+	console.log("                         STATISTIKA");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+
+	console.log(`  Skupaj vakcin:               ${vakcine.length}`);
+	console.log(`  Število različnih bolezni:   ${sortiraneBolezni.length}\n`);
+
+	console.log("  Po boleznih:");
+	for (const bolezen of sortiraneBolezni) {
+		const stevilo = poBoleznih[bolezen].length;
+		console.log(`    ${bolezen}: ${stevilo}`);
+	}
+
+	// ATC statistika
+	console.log("\n───────────────────────────────────────────────────────────────");
+	console.log("PO ATC KATEGORIJAH");
+	console.log("───────────────────────────────────────────────────────────────\n");
+
+	const poAtc: Record<string, number> = {};
+	for (const z of vakcine) {
+		const prefix = z.atcKoda?.substring(0, 4) || "BREZ";
+		poAtc[prefix] = (poAtc[prefix] || 0) + 1;
+	}
+
+	const atcOpisi: Record<string, string> = {
+		QI01: "Ptice (perutnina)",
+		QI02: "Govedo",
+		QI04: "Ovce in koze",
+		QI05: "Prašiči",
+		QI06: "Konji",
+		QI07: "Psi",
+		QI08: "Mačke",
+		QI09: "Več vrst / kombinirane",
+		QI20: "Druge vakcine",
+	};
+
+	const sortiraniAtc = Object.keys(poAtc).sort();
+	for (const atc of sortiraniAtc) {
+		const opis = atcOpisi[atc] || "";
+		console.log(`  ${atc}: ${poAtc[atc]} ${opis ? `(${opis})` : ""}`);
+	}
+
+	console.log("\n═══════════════════════════════════════════════════════════════\n");
+}
+
+if (import.meta.main) {
+	main();
+}