% Samuel Kroslak, 
% 3. rocnik 
% 24172 
%
%   Vytvorte  jednoduchy  databazovy  system  pre  pracu s udajmi
%   o receptoch, ktory by umoznil:
%   - zaradit recept, surovinu
%   - vyhladat recept (skupinu receptov) podla zadanych kriterii
%     (meno, pouzite suroviny)
%   - zoradit recepty podla zvoleneho typu udaja (mena, ceny,
%     casu pripravy)
%   - zistit cenu receptu pre dany pocet osob
%   - zistit, ktore recepty pripadaju do uvahy, ak mame 'nejake'
%     suroviny 
%   Na konci cinnosti vytvorenu databazu receptov ulozi do suboru
%   (ktory bude obsahovat fakty o jednotlivych receptoch) a umozni
%   nacitanie databazy zo suboru do datoveho sveta Arity/Prologu.
%
%   udaje v databaze musia obsahovat minimalne:
%   - meno receptu
%   - potrebne suroviny spolu s ich mnozstvom
%   - cas pripravy
%   - ceny surovin
%   !!!! Pracujte s datovym svetom ARITY/PROLOGU

main :-
	repeat, 
	[!menu, get(InputInt), nl, case(InputInt)!], fail.

menu :-
	nl, 
	write('[1] Zarad recept'), nl,
	write('[2] Zarad surovinu'), nl,
	write('[3] Vyhladaj recept'), nl,
	write('[4] Zorad recepty'), nl,
	write('[5] Zisti cenu receptu'), nl,
	write('[6] Najdi recepty podla surovin'), nl,
	write('[7] Nacitaj z databazy'), nl,
	write('[8] Uloz do databazy'), nl,
	write('[0] Koniec'),nl,

% quit 
case(48) :- 
	nl, write('Koniec programu'), nl, abort.

% add receipe 
case(49) :-
	nl, write('Zaradenie receptu'), nl,
	enterName(Name),
	write('Suroviny:'), nl,
	ingredients(I),
	enterTime(Cas),
	recept(Name, I, Cas)=..[recept, Name, I, Cas],
	recordz(recepty, recept(Name, I, Cas), REF).

enterName(Meno) :-
	write('Meno receptu:  '),
	read_string(50, X), string_term(X, Meno),
	((string_length(X, 0), main);
	(var(Meno), write('Meno musi zacinat malym pismenom!'), nl, main);
	(Str=..[recept, Meno, _, _],
	not(recorded(recepty, Str, _)));
	(write('Recept s tymto menom existuje!'), nl, main)).

enterTime(Cas) :-
	write('Cas pripravy [min]:  '),
	read_string(50, X), string_term(X, Pomoc),
	((string_length(X, 0), main);
	(integer(Pomoc), Pomoc > 0, Cas = Pomoc);
	(write('Nespravne zadany cas!'), nl, zadaj_cas(Cas))).

ingredients([H1-H2|T]):-
	write('Meno ingredients:  '),
	read_string(50, X), string_term(X, Meno),
	((string_length(X, 0), main);
	(Struct=..[surovina, Meno, _],
	recorded(ingredients, Struct, _));
	(write('Neznama surovina!'), nl, main)),
	write('Mnozstvo [g],[ml]:  '),
	read_string(50, Y), string_term(Y, Mnozstvo),
	((string_length(Y, 0), main);
	((not(number(Mnozstvo)); Mnozstvo =< 0),
	write('Zle zadane mnozstvo!'), nl, main );
	(number(Mnozstvo), Mnozstvo > 0,
	H1 = Meno, H2 = Mnozstvo)),
	write('Dalsiu surovinu [A/N]:  '), get(Dalej), nl,
	ifthenelse(Dalej =:= 97, ingredients(T), T = []).

%pridanie ingredients
case(50) :-
	meno_sur(Meno), cena_sur(Cena),
	surovina(Meno, Cena)=..[surovina, Meno, Cena],
	recordz(ingredients, surovina(Meno, Cena), REF).

meno_sur(Meno) :-
	write('Meno ingredients:  '),
	read_string(50, X), string_term(X, Pomoc),
	((string_length(X, 0), main);
	(var(Pomoc), write('Meno musi zacinat malym pismenom!'), nl, meno_sur(Meno));
	(Struc=..[surovina, Pomoc, _],
	recorded(ingredients, Struc, _),
	write('Tato surovina je v databaze!'),
	nl, meno_sur(Meno));
	Meno = Pomoc).

cena_sur(Cena) :-
	write('Cena ingredients za [kg], [l]:  '),
	read_string(50, X), string_term(X, Pomoc),
	((string_length(X, 0), main);
	(number(Pomoc), Pomoc > 0, Cena = Pomoc);
	(write('Zle zadana cena!'), nl, cena_sur(Cena))).

%
case(51) :-
	podmenu1, get(Vyber), nl,
	hladaj(Vyber).

podmenu1 :-
	nl, write('1. Vyhladat recept podla mena'), nl,
	write('2. Vyhladat recept podla surovin'), nl,
	write('3. Vyhladat vsetky recepty'), nl,
	write('4. Vyhladat vsetky ingredients'), nl,
	write('0. Navrat do hlavneho menu'), nl,
	write('Zadaj volbu:  ').

cit_meno(Meno) :-
	write('Meno receptu:  '),
	read_string(50, X), string_term(X, Pomoc),
	((string_length(X, 0), main);
	(nonvar(Pomoc),
	Meno = Pomoc)).

hladaj(48).

hladaj(49) :-
	nl, write('Hladanie receptu podla mena:'), nl,
	cit_meno(Meno), !,
	(recept(Meno, Suroviny, Cas)=..[recept, Meno, Suroviny, Cas],
	recorded(recepty, recept(Meno, Suroviny, Cas), _)),
	nl, write('Meno:  '), write(Meno), nl,
	write('Cas:  '), write(Cas), nl,
	write('Suroviny:  '), write(Suroviny), nl.

vypis([]).
vypis([X|Y]):-
	X=..[_, Meno, Suroviny, Cas],
	write('Meno:  '), write(Meno), nl,
	write('Cas pripravy:  '), write(Cas), nl,
	write('Pouzite ingredients:  '), write(Suroviny), nl, nl,
	get0_noecho(_), vypis(Y).

vypis_sur([]).
vypis_sur([H|T]):-
	write(H), nl, vypis_sur(T).

vypis_surovin([], 0).
vypis_surovin([Surovina-Mnozstvo-Cena|T], Cena1) :-
	write(Surovina), write(' - '),
	write(Mnozstvo), nl,
	vypis_surovin(T, Cena2),
	Cena1 is Cena2 + Mnozstvo * Cena.

hladaj(50) :-
	nl, write('Hladanie receptu podla surovin:'), nl,
	ingredients1(Suroviny), nl,
	not(najdi(Suroviny)).

hladaj(51) :-
	findall(X, recorded(recepty, X, _), Zoznam),
	vypis(Zoznam).

hladaj(52) :-
	findall(X, recorded(ingredients, X, _), Zoznam),
	vypis_sur(Zoznam).

ingredients1([H|T]):-
	write('Meno ingredients:  '),
	read_string(50, X), string_term(X, Meno),
	((string_length(X, 0), main);
	((surovina(Meno, _)=..[surovina, Meno, _],
	not(recorded(ingredients, surovina(Meno, _), _))),
	write('Neznama surovina!'), nl, main);
	H = Meno),
	write('Dalsiu surovinu [A/N]:  '), get(Dalej), nl,
	ifthenelse((Dalej =:= 65; Dalej =:= 97), ingredients1(T), T = []).

najdi(Suroviny) :-
	recept(Meno, X, Cas)=..[recept, Meno, X, Cas],
	recorded(recepty, recept(Meno, X, Cas), _),
	jev(Suroviny, X),
	write('Meno:  '), write(Meno), nl,
	write('Cas:  '), write(Cas), nl,
	write('Suroviny:  '), write(X), nl, nl,
	get0_noecho(_), fail.

jev([], X).
jev([Surovina|T], X) :-
	not(niejev(X, Surovina)),
	jev(T, X).

niejev([], X).
niejev([H-_|T], X) :- H \= X, niejev(T, X).

%zoradit recepty
case(52) :-
	menu2, get(Vyber), nl,
	zorad(Vyber).

menu2 :-
	nl, write('1. Zoradit recepty podla mena'), nl,
	write('2. Zoradit recepty podla ceny'), nl,
	write('3. Zoradit recepty podla casu pripravy'), nl,
	write('0. Navrat do hlavneho menu'), nl,
	write('Zadaj volbu:  ').

zorad(50) :-
	findall(C-M, (recorded(recepty, recept( M, S, _),_),scitaj(S,C)), Y),
	sort(Y, Z),
	tr(Z,X),
	vypis_rec(X).

tr([],[]).
tr([C-M|T],[M|T2]) :-	tr(T,T2).

%zoradenie podla ceny
zorad(49) :-
	findall(Meno, recorded(recepty, recept(Meno, _, _), _), Y),
	sort(Y, Z),
	vypis_rec(Z).

vypis_rec([Meno|T]) :-
	recorded(recepty, recept(Meno, X, Cas), _),
	write('Meno:  '), write(Meno), nl,
	write('Cas:  '), write(Cas), nl,
	write('Suroviny:  '), write(X), nl,
	write('Cena:  '), scitaj(X,Y), write(Y),nl,nl,
	get0_noecho(_), vypis_rec(T).
vypis_rec([]).


zorad(48).
zorad(51) :-
	findall(Cas, recorded(recepty, recept(_, _, Cas), _), Y),
	sort(Y, Z),
	vypis_rec_cas(Z).

vypis_rec_cas([Cas|T]) :-
	recorded(recepty, recept(Meno, X, Cas), _),
	write('Meno:  '), write(Meno), nl,
	write('Cas:  '), write(Cas), nl,
	write('Suroviny:  '), write(X), nl, nl,
	get0_noecho(_), vypis_rec_cas(T).
vypis_rec_cas([]).

%zisti cenu receptu
case(53) :-
	nl, write('Zistenie ceny: '), nl,
	cit_meno(Meno), cit_pocet(Pocet),
	recept(Meno, Suroviny, _)=..[recept, Meno, Suroviny, _], !,
	recorded(recepty, recept(Meno, Suroviny, _), _),
	scitaj(Suroviny, Cena),
	VCena is Cena * Pocet,
	write('Recept '), write(Meno) ,
	write(' pre pocet osob: '), write(Pocet),
	write(' bude stat: '), write(VCena), nl.

cit_pocet(Pocet) :-
	write('Zadaj pocet osob:  '), read_string(50, X),
	string_term(X, Pomoc),
	((string_length(X, 0), main);
	(integer(Pomoc), Pomoc > 0, Pocet = Pomoc);
	(write('Zly pocet osob!'), nl, cit_pocet(Pocet))).

scitaj([], 0).
scitaj([Meno-Mnozstvo|T], Cena) :-
	surovina(Meno, C)=..[surovina, Meno, C],
	recorded(ingredients, surovina(Meno, C), _),
	scitaj(T, C1),
	Cena is C * (Mnozstvo / 1000) + C1.

%najst recepty
case(54) :-
	write('Suroviny:'), nl,
	ingredients1(Suroviny), nl,
	hladaj(Suroviny).

hladaj(Suroviny) :-
	recept(Meno, X, Cas)=..[recept, Meno, X, Cas],
	recorded(recepty, recept(Meno, X, Cas), _),
	urobi(Suroviny, X),
	write('Meno:  '), write(Meno), nl,
	write('Cas:  '), write(Cas), nl,
	write('Suroviny:  '), write(X), nl, nl,
	get0_noecho(_),
	fail.

urobi(Suroviny, []).
urobi(Suroviny, [X-_|T]) :- not(nenachadza1(Suroviny, X)), urobi(Suroviny, T).

nenachadza1([], X).
nenachadza1([H|T], X) :- H \= X, nenachadza1(T, X).

%nacitanie databazy
case(55) :-
	fileerrors(_, off),
	(open(H, databaza, r); write('Subor data neexistuje!'), nl, fail),
	fileerrors(_, on),
	repeat,
	read(H, X),
	(X = end_of_file, !, close(H);
	((X =.. [recept|T],not(recorded(recepty, X, _)),recordz(recepty, X, REF));
	(X =.. [surovina|T],not(recorded(ingredients, X, _)),recordz(ingredients, X, REF));
	true),
	fail).

%uloz databazu
case(56) :-
	create(H, databaza),
	(recorded(recepty, X, _);recorded(ingredients, X, _)),
	[!writeq(H, X), writeq(H, .), nl(H)!],
	fail.

case(56) :- open(H, databaza, r), close(H), X is H - 1, close(X).