% Informacion para los casos de prueba
% ====================================
%

% Definiciones de bloques:
bloque(bloque1, 3, 4, rojo).
bloque(bloque2, 2, 2, verde).
bloque(bloque3, 1, 0, amarillo).
bloque(bloque4, 2, 0, azul).
bloque(cuboGrande, 3, 3, rojo).
bloque(cuboMediano, 2, 2, azul).
bloque(cuboChico, 1, 1, rojo).
bloque(piramide, 2, 0, verde).

% Estados de prueba:
estado0([sobre(piso, cuboGrande), sobre(piso, piramide),
    sobre(piso, cuboMediano), sobre(cuboMediano, cuboChico)]).
estado1([sobre(piso, bloque1), sobre(piso, bloque2), sobre(bloque2, bloque3)]).
estado1dups([sobre(piso, bloque1), sobre(piso, bloque2),
    sobre(bloque2, bloque3), sobre(piso, bloque1)]).
estado2([sobre(piso, cuboGrande), sobre(cuboGrande, cuboMediano),
    sobre(cuboGrande, cuboChico)]).
estado3([sobre(piso, cuboGrande), sobre(piso, cuboMediano),
    sobre(cuboGrande, cuboMediano)]).
estado4([sobre(cuboGrande, cuboMediano), sobre(cuboMediano, cuboChico)]).
estado5([sobre(piso, cuboGrande), sobre(cuboGrande, cuboMediano),
    sobre(cuboGrande, piramide)]).
estado6([sobre(cuboGrande, cuboGrande)]).
estado7([sobre(piso , cuboGrande), sobre(cuboGrande, cuboChico),
    sobre(cuboGrande, piramide)]).
estado8([sobre(piso, bloque1), sobre(bloque2, bloque3)]).

estado10([sobre(piso , cuboGrande) ,sobre(piso , cuboMediano) ,sobre(cuboMediano, cuboChico)]).


% Ejercicio 1: Solucion
% =====================

% bloques(+Estado, -Bloques)
%   Predicado que es verdadero si y solo si Bloques es una lista sin
%   repetidos de todos los bloques que figuran en el estado Estado, sin
%   incluir el piso.
%   Para verificarlo:
%   * se consigue una lista de todos los componentes (bloques y piso) del
%     estado usando el predicado componentes/2,
%   * se quitan los duplicados de dicha lista mediante quitarDuplicados/2,
%   * se eliminan las ocurrencias del piso en la lista a traves
%     de quitarPiso/2
%   * se corrobora que Bloques sea una permutacion de la lista obtenida.
%   La implementacion permite obtener un valor para Bloques dado un estado
%   especifico.
bloques(Estado, Bloques) :- componentes(Estado, Componentes),
    quitarDuplicados(Componentes, ComponentesSinDuplicados),
    quitarPiso(ComponentesSinDuplicados, PosibleBloquesResultado),
    permutation(PosibleBloquesResultado, Bloques), !.

% componentes(+Estado, -Componentes)
%   Predicado que es verdadero si y solo si Componentes es una lista
%   generada reemplazando cada elemento sobre(X, Y) de Estado por dos
%   elementos X e Y.
componentes([], []).
componentes([sobre(X, Y)|Ss], [X, Y|Es]) :- componentes(Ss, Es).

% quitarDuplicados(+L1, -L2)
%   Predicado que es verdadero si y solo si L2 es el resultado de aplicar
%   el siguiente procedimiento:
%   1. Para cada elemento E de L1:
%   2.  si E se encuentra luego en la lista, quitar la ocurrencia actual
%   Se podria implementar este predicado, aunque requiriendo que L2 se
%   encuentre ordenada, del siguiente modo:
%   quitarDuplicados(L1, L2) :- setof(X, member(X, L1), L2).
%   O, sin esa restriccion, como sigue:
%   quitarDuplicados(L1, L2) :- list_to_set(L1, L2).
quitarDuplicados([], []).
quitarDuplicados([X|Xs], Ys) :- member(X, Xs), quitarDuplicados(Xs, Ys).
quitarDuplicados([X|Xs], [X|Ys]) :- not(member(X,Xs)), quitarDuplicados(Xs, Ys).

% quitarPiso(+L1, -L2)
%   Predicado que es verdadero si y solo si L2 es el resultado de aplicar
%   el siguiente procedimiento:
%   1. Para cada elemento E de L1:
%   2.  si E unifica con piso, quitar la ocurrencia actual
%   Este predicado podria implementarse como:
%   quitarPiso(L1, L2) :- delete(L1, piso, L2).
quitarPiso([], []).
quitarPiso([X|Xs], Ys) :- X = piso, quitarPiso(Xs, Ys).
quitarPiso([X|Xs], [X|Ys]) :- X \= piso, quitarPiso(Xs, Ys).

% Ejercicio 1: Test cases
% =======================
% estado1(E), bloques(E, X).


% Ejercicio 2: Solucion
% =====================

% baseDe(+Estado, -A, -B)
%   Predicado que es verdadero si y solo si, en el estado Estado, el
%   bloque B esta apoyado sobre la superficie A.
%   Simplemente se verifica si sobre(A, B) es un elemento de Estado.
baseDe(Estado, A, B) :- member(sobre(A, B), Estado).

% Ejercicio 2: Test cases
% =======================
% estado1(E), baseDe(E, X, bloque2).
% estado1(E), baseDe(E, X, Y).


% Ejercicio 3: Solucion
% =====================

% apoyadosSobre(+Estado, +A, -Bs)
%   Predicado que es verdadero si y solo si, en el estado Estado, la
%   lista Bs contiene (sin repetir) a todos los bloques apoyados sobre
%   A.
%   Para verificarlo, se obtienen, utilizando baseDe/3, todos los bloques
%   apoyados sobre A y, mediante el predicado setof/3 se instancia una
%   lista sin repetidos con todos ellos. Luego, se verifica que Bs sea una
%   permutacion de la lista obtenida.
%   La implementacion permite obtener un valor para Bs dados un Estado y
%   un componente A.
apoyadosSobre(Estado, A, Bs) :- findall(X, baseDe(Estado, A, X), BsConDups),
    quitarDuplicados(BsConDups, PosibleBs), permutation(PosibleBs, Bs), !.


% Ejercicio 3: Test cases
% =======================
% estado1(E), apoyadosSobre(E, piso, Bs).
% estado1(E), apoyadosSobre(E, bloque1, Bs).
% estado1(E), apoyadosSobre(E, bloque2, Bs).
% estado1(E), apoyadosSobre(E, bloque1, []).
% estado1dups(E), apoyadosSobre(E, piso, Bs).

% Ejercicio 4: Solucion
% =====================

%% falta q Brian nos confirme si tiene q fallar cuando la entrada posee duplicados
valido(Estado) :- quitarDuplicados(Estado,Estado), forall(member(X, Estado), X \= sobre(_, piso)),
    bloques(Estado, Bloques),
    forall(member(Bloque, Bloques), tieneUnaSolaBase(Estado, Bloque)),
    forall(member(Bloque, Bloques), tieneTechoSuficiente(Estado, Bloque)),
    forall(member(Bloque, Bloques), not(esParteDeUnCiclo(Estado, Bloque))).

tieneUnaSolaBase(Estado, Bloque) :- numeroDeBases(Estado, Bloque, 1).

numeroDeBases(Estado, Bloque, N) :- setof(X, baseDe(Estado, X, Bloque), Bases),
    length(Bases, N).

tieneTechoSuficiente(Estado, Bloque) :-
    apoyadosSobre(Estado, Bloque, Apoyados),
    sumaBases(Apoyados, SumaBasesApoyados),
    areaTechoDe(Bloque, AreaTecho),
    SumaBasesApoyados =< AreaTecho.

sumaBases(Bloques, SumaBases) :-
    maplist(areaBaseDe, Bloques, AreasBase),
    sumlist(AreasBase, SumaBases).

areaBaseDe(Bloque, AreaBase) :- bloque(Bloque, AreaBase, _, _).

areaTechoDe(Bloque, AreaTecho) :- bloque(Bloque, _, AreaTecho, _).

esParteDeUnCiclo(Estado, Bloque) :- baseDe(Estado, Base, Bloque),
    cicloEncontrado(Estado, Base, Bloque), !.

cicloEncontrado(_, Bloque, Bloque).
cicloEncontrado(Estado, Bloque, BloqueInicial) :- baseDe(Estado, Base, Bloque),
    cicloEncontrado(Estado, Base, BloqueInicial).

% Ejercicio 4: Test cases
% =======================
% estado2(E), valido(E). % (true)
% estado3(E), valido(E). % (false)
% estado4(E), valido(E). % (false)
% estado5(E), valido(E). % (false)
% estado6(E), valido(E). % (false)


% Ejercicio 5: Solucion
% =====================

% bloqueMovil(+Estado, -Bloque)
%   Predicado que es verdadero sii el bloque es móvil, o sea, si no hay
%   ningun bloque apoyado sobre el.
%   Para determinar esto, vemos primero que el bloque este en el estado, y
%   luego vemos que no sea un bloque que sirva de base a otros.
bloqueMovil(E, B) :- bloques(E, Bs), member(B, Bs), apoyadosSobre(E,B,[]).

% Ejercicio 5: Test cases
% =======================
% estado1(E), bloqueMovil(E, B).


% Ejercicio 6: Solucion
% =====================

% movimientoPosible(+Estado, -Movimiento)
%   Predicado que es verdadero sii Movimiento es un movimiento posible en el
%   estado Estado de la forma apoyarSobre(A, B).
%   Para determinar esto, vemos si A es tope (puede ser el piso o un bloque
%   de Estado), si B es un bloque de Estado y es movil, y que A y B sean
%   distintos.
movimientoPosible(E, apoyarSobre(A, B)) :-
    bloques(E, Bs),
    member(B, Bs), bloqueMovil(E, B),
    A \= B,
    not(baseDe(E, A, B)).

% Ejercicio 6: Test cases
% =======================
% estado7(E), movimientoPosible(E, M).
% estado2(E), movimientoPosible(E, M).
% movimientoPosible([sobre(piso, cuboGrande), sobre(piso, cuboChico)], M).


% Ejercicio 7: Solucion
% =====================
%
% realizarMovimiento(+EInicial, +Movimiento, -EFinal)
%   Predicado verdadero sii EFinal es el estado resultante de aplicar el
%   movimiento Movimiento en el estado EInicial, usando las reglas de
%   aplicacion que se encuentran en el enunciado.
%   Para esto, primero verificamos si el movimiento es posible, luego
%   determinamos el nuevo estado, y finalmente comprobamos que sea valido.
realizarMovimiento(EI, apoyarSobre(A, B), EF) :-
    movimientoPosible(EI, apoyarSobre(A, B)),
    sacarBloque(EI, B, ET),
    EF = [sobre(A, B)|ET],
    valido(EF).

% sacarBloque(+EI, +B, -EF)
%   Verdadero sii el estado EF es igual al estado EI sin el bloque B. Se
%   asume que el bloque B es un tope, y que EF es valido.
sacarBloque([], _, []).
sacarBloque([sobre(_, B)|Ss], B, Ss).
sacarBloque([sobre(A, B)|Ss], X, [sobre(A, B)|Fs]) :- sacarBloque(Ss, X, Fs).

% Ejercicio 7: Test cases
% =======================
% estado2(E), realizarMovimiento(E, apoyarSobre(piso, cuboMediano), EF).


% Ejercicio 8: Solucion
% =====================

% satisface(+Estado, +Objetivo)
%   Predicado que es verdadero si y solo si todos los requerimientos de la
%   lista Objetivo se satisfacen en el estado Estado.
%   Para verificarlo, debemos ver que, para cada elemento sobre(PA, PB) de
%   Objetivo, se cumpla que existen bloques A y B con propiedades PA y PB
%   respectivamente, y que A se encuentre sobre B en el estado Estado.
satisface(_, []).
satisface(E, [sobre(PA, PB)|Os]) :-
        bloque(A, _, _, PA), bloque(B, _, _, PB),
        member(sobre(A, B), E),
        satisface(E, Os).


% Ejercicio 9: Solucion
% =====================

% resolver (+ EInicial , +Objetivo, −Movimientos, −EFinal) nums(X,X).


resolver(EI,Obj,Movs, EF) :- buffResolver(EI,Obj,[],Movs, EF).
buffResolver(EI,Obj,Movs,Movs, EI) :- satisface(EI,Obj).
buffResolver(EI,Obj,BMovs,Movs, EF) :- movimientoPosible(EI,N), not(member(N,BMovs)), realizarMovimiento(EI,Obj,EN),
    append(BMovs,[EN],NBMovs), buffResolver(EI,Obj,BMovs, Movs,EF).



% resolver(EI, Obj, Movs, EF) :- nums(0, N), secMovs(EI,N, LMovs), member(Movs, LMovs),
%   realizarMovs(EI, Movs, EF), satisface(EF, Obj).

nums(X,Y) :- Z is X + 1, nums(Z,Y).

secMovs(EI, N, LMovs) :- setof(X, secMovimientos(EI, N, X), LMovs).

realizarMovs(EI, [], EI).
realizarMovs(EI, [M|Ms], EF) :- realizarMovimiento(EI, M, ET), realizarMovs(ET, Ms, EF).

secMovimientos(_, 0, []).
secMovimientos(E, N, [X|Movs]) :- valido(E), movimientoPosible(E, X),
    realizarMovimiento(E, X, EF), NMenosUno is N - 1, NMenosUno >= 0,
    secMovimientos(EF, NMenosUno, Movs).