#include io.cam
#include sets.cam
#include ffs.cam
#include txt.cam
#include sql.cam

/*****************************************************************************
 *                                                                           *
 *      1. The Specification                                                 *
 *                                                                           *
 *****************************************************************************/

TYPE
        BAMS = AccId -> Account;
        Account :: H: AccHolder-set
                   B: Amount;
        AccId   = STR;
        AccHolder = STR;
        Amount  = INT;
;       Void    = SYM;

ENDTYPE

STATE bams: BAMS;

;-----------------------------------------------------------------------------
FUNC Init():Void
;-----------------------------------------------------------------------------
STATE
bams <-
[
  "0636024550431"-> Account( { "J N Oliveira","L.S. Barbosa"}, 3000),
  "0636024000999"-> Account( { "Neves,  Fernando L.","J N Oliveira"}, 9000 ),
  "0636099999000"-> Account( { "J.J.A."   },   9500 ),
  "0636055566677"-> Account( {            },   10 )
];

;-----------------------------------------------------------------------------
FUNC OpenAccount(n:AccId,h:AccHolder-set,m:Amount):Void
;-----------------------------------------------------------------------------
STATE bams <- [ n -> Account(h,m) ] + bams;

;-----------------------------------------------------------------------------
FUNC RemoAccount(n:AccId):Void
;-----------------------------------------------------------------------------
STATE bams <- bams \ { n };

;-----------------------------------------------------------------------------
FUNC AddAccHolders(n:AccId,h:AccHolder-set):Void
;-----------------------------------------------------------------------------
STATE bams <- bams + let (addh=lambda(x).Account(H(x) U h,B(x)))
                     in (*->addh)(bams/{n});


;-----------------------------------------------------------------------------
FUNC Credit(n:AccId,m:Amount):Void
;-----------------------------------------------------------------------------
STATE
bams <- bams + let (addm=lambda(x).Account(H(x), B(x) .+ m))
               in (*->addm)(bams/{n});


;-----------------------------------------------------------------------------
FUNC Withdraw(n:AccId,m:Amount):Void
;-----------------------------------------------------------------------------
STATE
bams <- bams + let (subm=lambda(x).let (b=B(x),
                                        c= if b >= m then b .- m else b)
                                   in Account(H(x), c))
               in (*->subm)(bams/{n});

;-----------------------------------------------------------------------------
FUNC GoodCostumers(m:Amount):AccHolder-set
;-----------------------------------------------------------------------------
RETURN UNION( { H(bams[k]) | k <- dom(bams): B(bams[k]) >= m });


;-----------------------------------------------------------------------------
; Initialization
;-----------------------------------------------------------------------------
;Init();
;-----------------------------------------------------------------------------

/*****************************************************************************
 *                                                                           *
 *      2. The Reification Process                                           *
 *                                                                           *
 *****************************************************************************/

abs0 <- (*->lambda(x).Account(p1(x),p2(x)));
;rep0 <- (*->const(lambda(x).H(x),lambda(x).B(x)));

;abs1 <- (*->const(p2,p1));
;rep1 <- (*->const(p2,p1));

abs2 <- (*->prod(id,dom));
rep2 <- (*->prod(id,ffAset));

abs3 <- nJoin;
rep3 <- nJoinInv;

abs4 <- prod(id,ffAset);
rep4 <- prod(id,dom);

abs5 <- prod(mkf,id);
rep5 <- prod(mkr,id);

abs6 <- prod(ff2pair-set,ff2pair-set);
rep6 <- prod(seq2ff-set,seq2ff-set);

abs7()= let (ss = abs7_2(),
              _ = nload("_bamsAmsTable"))
        in < _bamsAmsTable, ss >;
abs7_2() = ioAwk2afs("_bamsAccHolTable","%");
rep7(r) = do(_bamsAmsTable<-p1(r),
             ioObjSave('_bamsAmsTable,p1(r)),
             ioAfs2awk("_bamsAccHolTable",p2(r),"%")
            );

abs6to0(r)=abs0(abs1(abs2(abs3(abs4(abs5(abs6(r)))))));
rep0to6(a)=rep6(rep5(rep4(rep3(rep2(rep1(rep0(a)))))));

a()=abs6to0(abs7());
r()=rep7(rep0to6(bams));

/*****************************************************************************
 *                                                                           *
 *      3. The Implementation (Level 7)                                      *
 *                                                                           *
 *****************************************************************************/


;-----------------------------------------------------------------------------
FUNC Init7():Void
;-----------------------------------------------------------------------------
STATE rep7(rep0to6(
[
  "0636024550431"-> Account( { "J N Oliveira","L.S. Barbosa"}, 3000),
  "0636024000999"-> Account( { "Neves,  Fernando L.","J N Oliveira"}, 9000 ),
  "0636099999000"-> Account( { "J.J.A."   },   9500 ),
  "0636055566677"-> Account( {            },   10 )
]));

;-----------------------------------------------------------------------------
FUNC OpenAccount7(n:AccId,h:AccHolder-set,m:Amount):Void
;-----------------------------------------------------------------------------
STATE do(ioObjLoad('_bamsAmsTable),
         if card(sqlSelect(_bamsAmsTable, {1,2}, 1, lambda(x).x==n))==0
         then let (a=_bamsAmsTable U { [ 1 -> n, 2 -> m ] },
                   b= { [ 1 -> n, 2 -> i ] | i <- h })
              in do(
                    _bamsAmsTable <- a,
                    ioObjSave('_bamsAmsTable,a),
                    ioAfs2awk("_tmp0",b,"%"),
                    sh("cat _tmp0 _bamsAccHolTable > _tmp1"),
                    sh("cp  _tmp1 _bamsAccHolTable "),
                    sh("ls -l     _bamsAccHolTable ")
                   )
         else "\nSorry, account exists");

;-----------------------------------------------------------------------------
FUNC RemoAccount7(n:AccId):Void
;-----------------------------------------------------------------------------
STATE do(ioObjLoad('_bamsAmsTable),
         _bamsAmsTable <- sqlDelete(_bamsAmsTable, 1, lambda(x).n==x),
         ioObjSave('_bamsAmsTable,_bamsAmsTable),
         sh("awk '{ FS=\"%\"; if ($1!="
            ++ n ++ 
            ") print }' _bamsAccHolTable > _tmp"),
         sh("cp _tmp _bamsAccHolTable"),
         "\n[ successful awk call ]"
        );

;-----------------------------------------------------------------------------
FUNC Withdraw7(n:AccId,m:Amount):Void
;-----------------------------------------------------------------------------
STATE do(ioObjLoad('_bamsAmsTable),
         if card(
                sqlSelect(sqlSelect(_bamsAmsTable, {1,2}, 1, lambda(x).x==n),
                          {1,2}, 2, lambda(x).x>=m),
                )==0
         then "\nNon-existing account or insufficient balance"
         else do(
              _bamsAmsTable <-
              sqlUpdate(_bamsAmsTable, 2, lambda(x).x .- m, 1, lambda(x).n==x),
              ioObjSave('_bamsAmsTable,_bamsAmsTable)
                )
        );

;-----------------------------------------------------------------------------
FUNC AddAccHolders7(n:AccId,h:AccHolder-set):Void
;-----------------------------------------------------------------------------
STATE let (a = sqlSelect(_bamsAmsTable,{1},1,lambda(x).x==n),
           b = { [ 1 -> n, 2 -> i ] | i <- h },
           c = ffsJoin(a,b))
      in do(
              ioAfs2awk("_tmp0",c,"%"),
              sh("cat _tmp0 _bamsAccHolTable | sort -u > _tmp1"),
              sh("cp  _tmp1 _bamsAccHolTable "),
              sh("ls -l     _bamsAccHolTable "),
              "\n[ ffsJoin performed at CAMILA level ]"
           );

;-----------------------------------------------------------------------------
FUNC Credit7(n:AccId,m:Amount):Void
;-----------------------------------------------------------------------------
STATE do(ioObjLoad('_bamsAmsTable),
         _bamsAmsTable <-
               sqlUpdate(_bamsAmsTable, 2, lambda(x).m .+ x, 1, lambda(x).n==x),
         ioObjSave('_bamsAmsTable,_bamsAmsTable)
        );

;-----------------------------------------------------------------------------
FUNC GoodCostumers7(m:Amount):AccHolder-set
;-----------------------------------------------------------------------------
RETURN let (a = sqlSelect(_bamsAmsTable, {1}, 2, lambda(x).x>=m),
            _ = do(
                   ioAfs2awk("_tmp",a,"%"),
                   sh("sort _tmp > _tmp0"),
                   sh("sort _bamsAccHolTable > _tmp1"),
                   sh("ls -l _tmp0 _tmp1 "),
                   sh("join -t % _tmp0 _tmp1 > _tmp"),
                   princ("[ join performed at UNIX level ]\n\n")
                  ),
            b = ioAwk2afs("_tmp","%"))
       in ffsPro(2,b);

/*****************************************************************************
 *                                                                           *
 *      4. Extra Reification Laboratory Functionality                        *
 *                                                                           *
 *****************************************************************************/

ROLLBACK2REP()= bams <- abs6to0(abs7());

ROLLBACK2ABS()= rep7(rep0to6(bams));

/*****************************************************************************
 *                                                                           *
 *      5. Screen and LaTeX Interface Functions                              *
 *                                                                           *
 *****************************************************************************/

view0(x)=ioAfsPrint(show0(rep0(x)));
tex0(x)=ioTxtPrint(ffs2TeXtxt(show0(rep0(x))));
show0(x)= let (f=lambda(x).strCAT(seqAddSep(<a | a <- x>, " + ")),
               y=(*->prod(f,itoa))(x),
               z= { [ "AccId"->a,
                      "AccHolders"->p1(y[a]),
                      "Balance"->p2(y[a])
                    ]
                  | a <- dom(y) })
          in z;

tex6(x)= let (a=show6(x),
              f=lambda(x).ioTxtPrint(ffs2TeXtxt(x)))
         in < f(p1(a)), princ(" ~~~~~\n "), f(p2(a)) >;
view6(x)= let (_=prod(ioAfsPrint,ioAfsPrint)(show6(x))) in "";
show6 <- prod((lambda(x).ffsRename([1->"AccId",2->"Balance"],x)),
              (lambda(x).ffsRename([1->"AccId",2->"AccHolder"],x)));