% FÁBRICA

% Linhas
linhas([lA]).

% Maquinas
maquinas([ma]).

% Ferramentas
ferramentas([fa,fa,fc]).

% Maquinas que constituem as Linhas
tipos_maq_linha(lA,[ma]).
% ...

% Operações
tipo_operacoes([opt1,opt2,opt3]).
% operacoes deve ser criado dinamicamente
operacoes([op1,op2,op3,op4,op5]).
%operacoes_atrib_maq depois deve ser criado dinamicamente
operacoes_atrib_maq(ma,[op1,op2,op3,op4,op5]).
%operacoes_atrib_maq(ma,[op1,op2]).

% classif_operacoes/2 deve ser criado dinamicamente %%atomic_concat(op,NumOp,Resultado)
classif_operacoes(op1,opt1).
classif_operacoes(op2,opt2).
classif_operacoes(op3,opt1).
classif_operacoes(op4,opt2).
classif_operacoes(op5,opt3).
% ...

% PRODUTOS

produtos([pA,pB,pC]).

operacoes_produto(pA,[opt1]).
operacoes_produto(pB,[opt2]).
operacoes_produto(pC,[opt3]).

% ENCOMENDAS

%Clientes
clientes([clA,clB]).

% prioridades dos clientes
prioridade_cliente(clA,1).
prioridade_cliente(clB,2).
% ...

% Encomendas do cliente,
% termos e(<produto>,<n.unidades>,<tempo_conclusao>)
encomenda(clA,[e(pA,1,100),e(pB,1,100)]).
encomenda(clB,[e(pA,1,110),e(pB,1,150),e(pC,1,300)]).
% ...

op_prod_client(op1,ma,fa,pA,clA,1,100,5,60).
op_prod_client(op2,ma,fb,pB,clA,1,100,6,30).
op_prod_client(op3,ma,fa,pA,clB,1,110,5,60).
op_prod_client(op4,ma,fb,pB,clB,1,150,6,30).
op_prod_client(op5,ma,fc,pC,clB,1,300,8,40).
% ...

% :- dynamic operacoes_atrib_maq/2.
% :- dynamic classif_operacoes/2.
% :- dynamic op_prod_client/9.
% :- dynamic operacoes/1.


% Dado uma máquina retorna uma lista de operações e o tempo de ocupação
heuristic_occupancy(M,L,T):-
    get_time(Ti),
    op_fe_sorted_list(M,L),
    occupation_time(semfer,L,T),
    get_time(Tf), Tcomp is Tf-Ti,
    write('Gerado em '), write(Tcomp),
    write(' segundos'),nl.

% Cria pares Ferramenta-Operacao
op_fe_pair(O,F-O):-op_prod_client(O,_,F,_,_,_,_,_,_).
% Cria uma lista de operacoes ordenada alfabeticamente pelas ferramentas das operações
op_fe_sorted_list(M,S):- operacoes_atrib_maq(M,L), maplist(op_fe_pair,L,X), keysort(X,Y), pairs_values(Y,S).
% Calcula tempo de ocupação de uma lista de operações
occupation_time(_,[],0).
occupation_time(F,[H|L],T):- op_prod_client(H,_,F1,_,_,_,_,Tset,Texec), occupation_time(F1,L,T1),
                            ((F1==F,!,T is Texec+T1);T is Tset+Texec+T1).


% Dado uma máquina retorna uma lista de operações e a soma dos tempos de atraso
heuristic_delay(M,L,T):-
    get_time(Ti),
    op_pr_sorted_list(M,L),
    delay_time(semfer,L,T,0,0),
    get_time(Tf), Tcomp is Tf-Ti,
    write('Gerado em '), write(Tcomp),
    write(' segundos'),nl.

% Cria pares Prazo-Operacao
op_pr_pair(O,P-O):-op_prod_client(O,_,_,_,_,_,P,_,_).
% Cria uma lista de operacoes ordenada, ascendente, pelos prazos
op_pr_sorted_list(M,S):- operacoes_atrib_maq(M,L), maplist(op_pr_pair,L,X), keysort(X,Y), pairs_values(Y,S).
% Calcula soma dos tempos de atraso de uma lista de operações
delay_time(_,[],T,_,Ta):- T is Ta,!.
delay_time(F,[H|L],T,To,Ta):- op_prod_client(H,_,F1,_,_,_,Prazo,Tset,Texec),
                            ((F==F1,!,To1 is To + Texec);To1 is To + Texec + Tset),
                            ((To1<Prazo,!,Ta1 is Ta);Ta1 is To1-Prazo+Ta),
                            delay_time(F1,L,T,To1,Ta1).


% A* para tempos de ocupação
aStar_occupancy(M,Cam,Custo):- operacoes_atrib_maq(M,L),aStar_occupancy2([(_,0,[],L)], Cam, Custo).
aStar_occupancy2([(_,Custo,L,[])|_],Cam,Custo):- reverse(L,Cam).
aStar_occupancy2([(_,Ca,LopTratadas,LOpFaltam)|Outros],Cam,Custo):-
                findall((CeX,CaX,Ltratadas,Lfaltam),
                        (((LopTratadas==[],!,first_operation(Op,C));LopTratadas = [OpA|_], next_operation(OpA,Op,C)),
                        delete(LOpFaltam,Op,Lfaltam),
                        Ltratadas = [Op|LopTratadas],
                        CaX is C + Ca,
                        op_prod_client(Op,_,F,_,_,_,_,_,_),
                        estimativa_occupancy(LOpFaltam,F,Ce),
                        CeX is CaX + Ce,
                        member(Op, LOpFaltam)),
                        Novos),
                append(Outros,Novos,Todos),
                sort(Todos,Ordenados),
                aStar_occupancy2(Ordenados,Cam,Custo).

% Estimativa usada no A* para tempos de setup
estimativa_occupancy(LOp,F,Estimativa):- findall(p(FOp,Tsetup),
                            (member(Op,LOp),op_prod_client(Op,_,FOp,_,_,_,_,Tsetup,_)),LFTsetup),
                            elimina_repetidos(LFTsetup,[p(F1,Tsetup)|L]),
                            ((F==F1,!,soma_setups(L,Estimativa));soma_setups([p(F1,Tsetup)|L],Estimativa)).
% Soma dos tempos de setup
soma_setups([],0).
soma_setups([p(_,Tsetup)|L],Ttotal):-soma_setups(L,T1), Ttotal is Tsetup+T1.


% A* para tempos de atraso
aStar_delay(M,Cam,Atraso):- operacoes_atrib_maq(M,L), aStar_delay2([(_,0,0,[],L)], Cam, Atraso,_).
aStar_delay2([(_,Atraso,Custo,L,[])|_],Cam,Atraso,Custo):- reverse(L,Cam).
aStar_delay2([(_,At,Ca,LopTratadas,LOpFaltam)|Outros],Cam,Atraso,Custo):-
                findall((CeX,AtX,CaX,Ltratadas,Lfaltam),
                        (((LopTratadas==[],!,first_operation(Op,C));LopTratadas = [OpA|_], next_operation(OpA,Op,C)),
                        delete(LOpFaltam,Op,Lfaltam),
                        Ltratadas = [Op|LopTratadas],
                        CaX is C + Ca,
                        op_prod_client(Op,_,_,_,_,_,Prazo,_,_),
                        (CaX<Prazo ->  AtX is At; AtX is CaX-Prazo+At),
                        op_prod_client(OpA,_,F,_,_,_,_,_,_),
                        estimativa_delay(LOpFaltam,F,CaX,Ce),
                        CeX is AtX + Ce,
                        member(Op, LOpFaltam)),
                        Novos),
                append(Outros,Novos,Todos),
                sort(Todos,Ordenados),
                aStar_delay2(Ordenados,Cam,Atraso,Custo).

% Estimativa usada no A* para tempos de setup
estimativa_delay([],_,_,0).
estimativa_delay([H|L],F,C,Estimativa):- estimativa_delay(L,F,C,Estimativa1),
    									 op_prod_client(H,_,F1,_,_,_,Prazo,Tset,Texec),
    									 (F==F1 -> Tocup is C+Texec; Tocup is C+Tset+Texec),
    									 (Tocup<Prazo ->  Ta is 0; Ta is Tocup-Prazo),
    									 (Ta < Estimativa1 -> Estimativa is Ta;Estimativa is Estimativa1).

% Calculo do tempo da primeira operacao<
first_operation(O,T):- op_prod_client(O,_,_,_,_,_,_,Tset,Texec), T is Tset + Texec.
% Calculo do tempo da proxima operacao
next_operation(C,O,T):- C \== O, op_prod_client(C,_,F,_,_,_,_,_,_), op_prod_client(O,_,F1,_,_,_,_,Tset,Texec),
    (F==F1 -> T is Texec; T is Tset + Texec).

% Elimina repetidos
elimina_repetidos([],[]).
elimina_repetidos([X|L],L1):-member(X,L),!,elimina_repetidos(L,L1).
elimina_repetidos([X|L],[X|L1]):-elimina_repetidos(L,L1).