MODULE DNAInvar EXPORTS Main;

(* Compute chain invariants *)

IMPORT  ParseParams, Process, FileRd, Wr, FileWr;
IMPORT  OSError, Thread, Stdio, Fmt, TextWr;

IMPORT PZLR3Chain, PZLRChain, PZSymbolChain;

FROM PZProc IMPORT Squeeze;
  
FROM Stdio IMPORT stderr;
 
<* FATAL Wr.Failure, Thread.Alerted, OSError.E *>

TYPE
  Options = RECORD
      inName: TEXT;         (* Input float chain file (without ".flv") *)
      outName: TEXT;        (* Output float/curv chain file name (without ".flc") *)
      epsilon: LONGREAL;    (* Estimated absolute curvature noise ??? *)
      delta: LONGREAL;      (* Estimated relative curvature noise ??? *)
    END;
   
PROCEDURE Main() =
  BEGIN
    WITH
      o = GetOptions(),
      rp = PZLR3Chain.Read(FileRd.Open(o.inName & ".flc")),
      p = rp.c^,
      cmt = rp.cmt & "\n" & PZInvarComments(o, NUMBER(p)),
      unit = rp.unit,
      cmt = cmt & "\n" & " - Invariant computed at filtered bio sequence"
    DO
      BioWriteFiles(p,cmt,unit,o.outName);  
      WITH
        cc =  BioQuantizeInvariantChain(p, o.epsilon, o.delta)^,
        ccCmt = cmt & "\n" & "Coded Invariant" & "\n"
      DO
        PZSymbolChain.Write(
          FileWr.Open(o.outName & ".cvc"), ccCmt, cc, 0.0d0, o.epsilon, o.delta
        ); 
      END;
    END
  END Main;
 
PROCEDURE BioQuantizeInvariantChain(
    READONLY  p: PZLR3Chain.T; 
    epsilon, delta: LONGREAL;
): REF PZSymbolChain.T =
  (*
    Given the invariant chain, converts it to a coded
    curvature chain.
  *)
  BEGIN 
    WITH 
      n = NUMBER(p),
      refLetter = NEW(REF PZSymbolChain.T, n),
      letter = refLetter^
    DO
     FOR i:= 0 TO n-1 DO 
       WITH 
          pi = p[i], x = pi[0], y = pi[1], 
          hX = MAX(-3.0d0, Squeeze(x, epsilon, delta)),
          hY = MAX(-3.0d0, Squeeze(y, epsilon, delta)),
          X = ROUND(MIN(+3.0d0, hX)), 
          Y = ROUND(MIN(+3.0d0, hY)),
          k =  7 * X + Y 
        DO
          IF k < 0 THEN
            letter[i] :=  VAL(ORD('a') - k - 1, CHAR);
          ELSIF k > 0 THEN 
            letter[i] :=  VAL(ORD('A') + k - 1, CHAR);
          ELSE 
            letter[i] :=  VAL(ORD('0'),CHAR);  
          END
        END
      END;
      RETURN refLetter
    END 
  END BioQuantizeInvariantChain;


PROCEDURE GetOptions(): Options =
  VAR o: Options;
  BEGIN
    WITH
      pp = NEW(ParseParams.T).init(stderr)
    DO
      TRY
        pp.getKeyword("-inName");
        o.inName := pp.getNext();

        pp.getKeyword("-outName");
        o.outName := pp.getNext();
        
        pp.getKeyword("-epsilon");
        o.epsilon := pp.getNextLongReal();
        
        pp.getKeyword("-delta");
        o.delta := pp.getNextLongReal();
        
        pp.finish();                                       
      EXCEPT                                                            
      | ParseParams.Error =>                                              
          Wr.PutText(stderr, "Usage: DNAInvar \\\n");
          Wr.PutText(stderr, "  -inName <name> \\\n");
          Wr.PutText(stderr, "  -outName <name> \\\n");
          Wr.PutText(stderr, "  -epsilon <number> -delta <number> \n");
        Process.Exit(1);
      END;
    END;
    RETURN o
    
  END GetOptions;


PROCEDURE PZInvarComments(READONLY o: Options; n : CARDINAL): TEXT =
  BEGIN 
    WITH 
      wr = NEW(TextWr.T).init()
    DO 
      Wr.PutText( wr, "PZInvar  inName: " & o.inName & "\n");
      Wr.PutText( wr, "         outName: " & o.outName & "\n");
      Wr.PutText( wr, "         epsilon: " & Fmt.LongReal(o.epsilon) & "\n");  
      Wr.PutText( wr, "         delta: " & Fmt.LongReal(o.delta) & "\n");  
      Wr.PutText( wr, "         n: " & Fmt.Int(n));  
      RETURN(TextWr.ToText(wr))
    END (* DO *);
  END PZInvarComments;

PROCEDURE BioWriteFiles(
  READONLY p:PZLR3Chain.T; 
  cmt: TEXT; 
  unit: LONGREAL; 
  outName: TEXT; 
) =
BEGIN 
  WITH 
    n = NUMBER(p),
    x = NEW(REF PZLRChain.T,n),
    y = NEW(REF PZLRChain.T,n)
  DO
    FOR i := 0 TO n-1 DO 
      x[i] := p[i,0];
      y[i] := p[i,1];
    END;
    PZLRChain.Write(FileWr.Open(outName & ".fat"), cmt, x^, 0.0d0, unit);
    PZLRChain.Write(FileWr.Open(outName & ".fcg"), cmt, y^, 0.0d0, unit);
  END;
END BioWriteFiles;

BEGIN
  Main()
END DNAInvar.