-module(przyklady).
-export([map/2,any/2,any_dwa/2,foreach/2,foreach_dwa/2,all/2,all_dwa/2,iloczynListFoldl/2,krotki/1,dropwhile/2,takewhile/2,zlicz_wystapienia/2,foldl_matrix/3,suma_wiersza/1,sum_matrix/1,sumowanie/1,sumowanie_nieparzystych/1,sumowanie_parzystych/1,zamien_liczbe/3,zamien_na_liczbe_przeciwna/1,zamien_na_wartosc_bezwzgledna/1,usun_nieparzyste/1,usun_ujemne/1]).

map(F,L)-> lists:foldl(fun (Arg, Acc)-> Acc++[F(Arg)] end, [], L).

%map(fun(X)->X*2 end,[1,2,3]).

any(F,L)-> Tmp = lists:foldl(fun(Arg,Acc)-> Acc++[F(Arg)] end, [], L),
           Tmp2 = lists:member(true, Tmp),
                if Tmp2 -> true;
                true -> false
           end.

any_dwa(Pred, L) ->
    InnerFun = fun(Element, Acc) ->
        PredResult = Pred(Element),
        if PredResult -> Acc++[Element];
        true -> Acc end end,
    FoldlResult = lists:foldl(InnerFun, [], L),
    if length(FoldlResult) == 0 -> false;
    true -> true end.

%any(fun(X)->X<2 end, [1,2,3,4,5]).

foreach(F, L) ->
    lists:foldl(fun(Arg,_)->F(Arg) end,ok,L).

foreach_dwa(Func, L) ->
    lists:foldl(fun(Element, Acc) -> Acc++[Func(Element)] end, [], L).

%foreach(fun(X)->erlang:display(X*2) end, [1,2,3]).

all(F, L) ->
        Tmp = lists:foldl(fun(Arg,Acc)->[F(Arg)]++Acc end, [], L),
        Tmp2 = lists:any(fun(X)->X==false end, Tmp),
        if
            Tmp2 -> false;  % tu można dopisać Tmp2 == true
            true -> true
        end.

all_dwa(Pred, L) ->
    InnerFun = fun(Element, Acc) ->
        PredResult = Pred(Element),
        if PredResult -> Acc++[Element];
        true -> Acc end end,
    FoldlResult = lists:foldl(InnerFun, [], L),
    if length(L) == length(FoldlResult) -> true;
    true -> false end.

iloczynListFoldl(L,L2) ->
        lists:foldl(fun(Arg,Acc)->Acc++[lists:foldl(fun(A,Ak)->Ak++[A*Arg] end,[],L2)] end,[],L).

krotki(Tuples) ->
       lists:foldl(fun(Tuple,Acc)-> if element(1,Tuple) == done -> Acc+element(2,Tuple); true -> Acc end end, 0, Tuples).

zlicz_wystapienia(Liczba, M)->lists:foldl(fun(Wiersz,Acc1)->Acc1+lists:foldl(fun(E,Acc2)->if E==Liczba -> Acc2+1; true->Acc2 end end,0,Wiersz)end,0,M).

foldl_matrix(F, Acc, Mat) ->
    Tmp = is_list(Acc),
    if Tmp ->
        lists:foldl(fun(X,Accum)->Accum++[lists:foldl(fun(C,A)->F(C,A) end, Acc,X)] end, Acc, Mat);
        true -> lists:foldl(fun(X,Accum)->Accum+(lists:foldl(fun(C,A)->F(C,A) end, Acc, X)) end, Acc, Mat)
    end.

suma_wiersza(Wiersz) -> lists:foldl(fun(Arg, Acc) when Arg rem 2 =/= 0 -> Acc+Arg;
                                       (_,Acc)->Acc end, 0, Wiersz).

sum_matrix(Matrix) -> lists:foldl(fun(Wiersz, Acc)-> Acc+suma_wiersza(Wiersz) end, 0, Matrix).

sumowanie(M) ->lists:foldl(fun(Wiersz,Acc1)->Acc1+lists:foldl(fun(E,Acc2)->Acc2+E end,0,Wiersz) end,0,M).

sumowanie_parzystych(M)->lists:foldl(fun(Wiersz,Acc1)->Acc1+lists:foldl(fun(E,Acc2) when E rem 2 == 0 ->Acc2+E; (_,Acc2)->Acc2 end,0,Wiersz) end,0,M).

sumowanie_nieparzystych(M)->lists:foldl(fun(Wiersz,Acc1)->Acc1+lists:foldl(fun(E,Acc2) ->if E rem 2 == 1 ->Acc2 +E; true ->Acc2 end end,0,Wiersz)end,0,M).

zamien_na_wartosc_bezwzgledna(M)->lists:foldl(fun(Wiersz, Acc1)->Acc1++[lists:foldl(fun(E,Acc2) when E<0 -> Acc2++[abs(E)];(E,Acc2)->Acc2++[E] end,[],Wiersz)] end,[],M).

zamien_na_liczbe_przeciwna(M)->lists:foldl(fun(Wiersz,Acc1)->Acc1++[lists:foldl(fun(E,Acc2) -> Acc2++[E*(-1)] end,[],Wiersz)]end,[],M).

zamien_liczbe(Liczba,Zmieniona,M)->lists:foldl(fun(Wiersz,Acc1)->Acc1++[lists:foldl(fun(E,Acc2)-> if E == Liczba -> Acc2++[Zmieniona]; true -> Acc2++[E] end end,[],Wiersz)] end,[],M).

usun_nieparzyste(M)->lists:foldl(fun(Wiersz,Acc1) -> Acc1++[lists:foldl(fun(E,Acc2) when E rem 2 == 0 -> Acc2++[E]; (_,Acc2)->Acc2 end, [], Wiersz)] end,[],M).

usun_ujemne(M)->lists:foldl(fun(Wiersz,Acc1)-> Acc1++[lists:foldl(fun(E,Acc2) when E>0 ->Acc2++[E];(_,Acc2)->Acc2 end,[],Wiersz)] end,[],M).

dropwhile(Func, L) ->
    try
        InnerFun = fun(Element, Acc) ->
            PredResult = Func(Element),
            if PredResult == false -> Acc + 1;
            true -> throw({bad_value, lists:sublist(L, Acc, length(L) - Acc + 1)}) end end,
        lists:foldl(InnerFun, 0, L)
    catch
        throw: {bad_value, Acc} ->  Acc end.

takewhile(Func, L) ->
    try
        InnerFun = fun(Element, Acc) ->
            PredResult = Func(Element),
            if PredResult -> Acc++[Element];
            true -> throw({bad_value, Acc}) end end,
        lists:foldl(InnerFun, [], L)
    catch
        throw: {bad_value, Acc} ->  Acc end.