// ==================================================================================
// Name.............: EWORK Heftungsscript - FixPageCount
// ----------------------------------------------------------------------------------
// Company..........: CTO Balzuweit GmbH
// ----------------------------------------------------------------------------------
// Creation.........: 18.07.2011
// Changed..........: 10.05.2019
// ==================================================================================

// ----------------------------------------------------------------------------------
// Die Funktion führt sofern konfiguriert für jedes Feld die Userexits und
// nachfolgende die Heftung aus.                                                     
// ----------------------------------------------------------------------------------
function executeUserExits(HALT_ON_ERROR,fromIndexToIndex):boolean;
var
  i    : Integer;
begin
  result := true;
  for i := 0 to ccFields.Count-1 do
  begin
    try
      ccApplication.ShowStatus('Executing userexits',ccFields.GetDisplayText(i),fromIndexToIndex[3]);
      ccApplication.ExecuteUserexit(i);
    except
      ccApplication.ShowStatus('Executing userexits','Error',fromIndexToIndex[3]);
      if HALT_ON_ERROR then
      begin
        result:=false;
      end;
      exit;
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion berechnet den Fortschritt in Prozentselectiert alle relevante Seiten
// fuer die aktuelle Heftung.
// ----------------------------------------------------------------------------------
function getExecutionStatusInProcent(position,maxCount):Integer;
begin
  if maxCount = 0 then
  begin
    result := 100;
    exit;
  end;
  result := position * 100 / maxCount;
end;

// ----------------------------------------------------------------------------------
// Die Funktion selectiert alle relevante Seiten fuer die aktuelle Heftung
// ----------------------------------------------------------------------------------
function selectPages(BlobList;startIndex;endIndex,SHOW_DOCS):Integer;
var
  selectPageFirst : Boolean;
  i               : Integer;
begin
  result          := 0;
  selectPageFirst := upperCase(ccScriptEngine.GetResource('PageVisibility','Last')) = 'FIRST' ;

  if selectPageFirst = true then
  begin
    for i := endIndex downto startIndex do
    begin
     ccApplication.SelectBlob(BlobList[i],SHOW_DOCS);
     inc(result);
    end;
  end else
  begin
    for i := startIndex to endIndex do
    begin
     ccApplication.SelectBlob(BlobList[i],SHOW_DOCS);
     inc(result);
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion führt die Heftung durch
// ----------------------------------------------------------------------------------
function executeTacks(BlobList,HALT_ON_ERROR, MOVE_FAILED_DOCS_TO_RESERVE,fromIndexToIndex):boolean;
var
   TackNr      : Integer;
   i           : Integer;
   TackId      : String;
   SeparatorId : Variant;
begin
  TackNr := fromIndexToIndex[2];
  TackId := CreateId;
  
  ccApplication.ShowStatus('Creating tack',inttostr(TackNr),fromIndexToIndex[3]);
  
  //SeperatorPage bestimmen
  SeparatorId := BlobList[fromIndexToIndex[1]];
                                                            
  if ccApplication.CreateTack(TackId) = false then
  begin                                                                  
    if HALT_ON_ERROR = True then
    begin                       
      result:=False;
      exit;
    end;    
    if MOVE_FAILED_DOCS_TO_RESERVE = True then
    begin
      //Do it in the reserve area... 
      for i:= fromIndexToIndex[0] to fromIndexToIndex[1] do
        ccApplication.ChangeBlob(BlobList[i],ccQS_OnHold,'');
    end;
  end; 
  
  Result := True;      
end;

// ----------------------------------------------------------------------------------
// Die Funktion führt selektiert alle Dokumente, führt sofern gewünscht die
// Userexits aus und heftet die Dokumente. Dabei wird über den Array fromIndexToIndex
// bestimmt von welchem Dokument zu welchem Dokument geheftet werden soll.     
// ----------------------------------------------------------------------------------
procedure BuildTack(lastRecoResult;Switch_Sep_UserExit_Move_Halt;BlobList;fromIndexToIndex,SHOW_DOCS);
var
  EXECUTE_USER_EXITS           : boolean;
  MOVE_FAILED_DOCS_TO_RESERVE  : boolean;
  HALT_ON_ERROR                : boolean;
  startIndex                   : Integer;
  toIndex                      : Integer;
  countPages                   : Integer;
begin
  EXECUTE_USER_EXITS              := Switch_Sep_UserExit_Move_Halt[0];
  MOVE_FAILED_DOCS_TO_RESERVE     := Switch_Sep_UserExit_Move_Halt[1];
  HALT_ON_ERROR                   := Switch_Sep_UserExit_Move_Halt[2];

  startIndex  :=fromIndexToIndex[0];
  toIndex     :=fromIndexToIndex[1];
  countPages  :=selectPages(BlobList,startIndex, toIndex,SHOW_DOCS);
  if countPages >0 then
  begin
    ccRecognition.FillIndexMask(lastRecoResult);
    if EXECUTE_USER_EXITS = True then
    begin
      if executeUserExits(HALT_ON_ERROR,fromIndexToIndex) = False then
        raise ('exception on execution user exits');
    end;
    if executeTacks(BlobList,HALT_ON_ERROR, MOVE_FAILED_DOCS_TO_RESERVE, fromIndexToIndex) = False then
      raise ('exception on tack execution');
  end

  ccApplication.UnSelectAllBlobs(ccWS_Stack);
  ccApplication.PrepareIndexmask;
end;

// ----------------------------------------------------------------------------------
// Die Funktion geht durch alle Recowerte die erfasst worden sind und gibt beim
// ersten das valide gefüllt wurde den Wert zurück.
// ----------------------------------------------------------------------------------*
function getRecoResult(actualRecoResult):String;
var
  i : Integer;
begin
  result := '';
  for i:=0 to High(actualRecoResult) do
  begin
    if actualRecoResult[i,1] >'' then
    begin
      result := actualRecoResult[i,1];
      exit;
    end;
  end;
end;

// ----------------------------------------------------------------------------------
// Die Funktion Verarbeitet je nach RecoModus der aus den Resourchen gelesen wird
// die Recognitionwerte.
// ----------------------------------------------------------------------------------
function AccumulateRecoResult(RecoModus:Integer;var LastValues, ActualValues: Variant):Variant;
var
  i : Integer;
begin
  for i:=0 to High(ActualValues) do
  begin

    case RecoModus of
    1 :  //Erster Wert
       begin
         if VarToStr(LastValues[i,1]) > '' then
         begin
           continue;
         end else
         begin
           if VarToStr(ActualValues[i,1]) > '' then
           begin
             LastValues[i,1] := ActualValues[i,1];
           end;
         end;
       end;
     2 :  //Letzter Wert
       begin
         if VarToStr(ActualValues[i,1]) > '' then
         begin
           LastValues[i,1] := ActualValues[i,1];
         end;
       end;
     else //Aufsummiert
       begin
          LastValues[i,1] := VarToStr(LastValues[i,1]) + ',' + ActualValues[i,1];
       end;
    end;
	
  end;
  
  Result := LastValues;
end;

// ----------------------------------------------------------------------------------
// Die Funktion gibt den gesetzten Recognition-Modus zurück Last ist Default
// ----------------------------------------------------------------------------------
function getRecognitionModus:Integer;
var
  Modus : String;
begin
  Modus := Uppercase(ccScriptEngine.GetResource('RecognitionFromModus','Last'));
  if Pos('CUMMULATE',Modus) > 0 then
  begin
    Result := 3;
  end else if Pos('FIRST',Modus) > 0 then
  begin
    Result := 1;
  end else
  begin
    Result := 2;
  end;
end;                     

var
  FIX_TACK_COUNT                  : Integer;
  RECOGNITION_MODUS               : Integer;
  EXECUTE_USER_EXITS              : Boolean;
  MOVE_FAILED_DOCS_TO_RESERVE     : Boolean;
  HALT_ON_ERROR                   : Boolean;
  DEBUG                           : Boolean;
  SHOW_DOCS                       : Boolean;
  LASTOBJECT                      : String;
  Switch_Sep_UserExit_Move_Halt   : Variant;
  FromIndexToIndex                : Variant;
  BlobList                        : Variant;
  actualRecoResult                : Variant;
  lastRecoResult                  : Variant;
  ListSize                        : Integer;
  tempRecoResults                 : Variant;
  tempDocCount                    : Integer;
  tempRecoResult                  : String;
  i                               : Integer;
  moveMode                        : Boolean;
  hasTempRecoResult               : Boolean;

begin
  //Anzahl Seiten nach der eine Heftung erfolgen soll
  FIX_TACK_COUNT               := ccScriptEngine.GetResource('PageCount',3);
  EXECUTE_USER_EXITS           := ccScriptEngine.GetResource('ExecuteUserexits',True);
  MOVE_FAILED_DOCS_TO_RESERVE  := ccScriptEngine.GetResource('MoveFailedDocsToReserve',False);
  HALT_ON_ERROR                := ccScriptEngine.GetResource('HaltOnError',False);
  DEBUG                        := ccScriptEngine.GetResource('Debug',True);
  LASTOBJECT                   := ccScriptEngine.GetResource('PageVisibility','Last');
  RECOGNITION_MODUS            := getRecognitionModus();
  SHOW_DOCS                    := VarToBoolean(ccScriptEngine.GetResource('Silent',False) = False);

  if DEBUG = True then
  begin
    showMessage('FixPageCount v2.0 - Parameter: PageVisibility=' + LASTOBJECT + ', ExecuteUserExits=' + VarToStr(EXECUTE_USER_EXITS) + ', MoveFailedDocs=' + VarToStr(MOVE_FAILED_DOCS_TO_RESERVE) +', FixCount='+intToStr(FIX_TACK_COUNT)+', HaltOnError='+VarToStr(HALT_ON_ERROR));
  end;

  Switch_Sep_UserExit_Move_Halt  := [ EXECUTE_USER_EXITS ,MOVE_FAILED_DOCS_TO_RESERVE ,HALT_ON_ERROR  ];
  fromIndexToIndex := [-1,-1,0,0]; //HeftungVonPage,HeftungToPage,Akt. HeftungNr, VerlaufInProzent

  try
    ccApplication.ShowStatus('Tacking','Initialize',0);
    ccApplication.UnSelectAllBlobs(ccWS_Stack);

    if ccScriptEngine.Application = 'EWORKBATCH' then
      ccApplication.PrepareIndexmask;

    //Liste aufbauen mit allen Blobs
    BlobList := ccApplication.GetBlobList(ccWS_Stack,false,'');

    //Anzahl Scans ermitteln
    ListSize := VarArrayHighBound(BlobList,1);

    //Verarbeiten nur wenn es Dokumente gibt.
    if ListSize >= 0 then
    begin
      fromIndexToIndex[0] := 0;
      tempDocCount        :=1;
      tempRecoResult      :='';
      moveMode            := false;
      hasTempRecoResult   := false;
  
      // Gehe durch alle Blobs
      for i:=0 to ListSize do
      begin
        //***************** Fortschritt ermitteln ******************
        fromIndexToIndex[3] := getExecutionStatusInProcent(i,ListSize);
  
        //***************** Führe für Seite I die Recognition durch ******************
        tempRecoResults := ccRecognition.Execute(BlobList[i]);


        tempRecoResult  := getRecoResult(tempRecoResults);

        if hasTempRecoResult = true then
        begin
          actualRecoResult:= AccumulateRecoResult(RECOGNITION_MODUS, actualRecoResult, tempRecoResults)
        end;


        if (tempRecoResult > '') and (hasTempRecoResult = false) then
        begin
          actualRecoResult := tempRecoResults;
          hasTempRecoResult:= true;
        end;


        if (moveMode = false) and (tempDocCount = FIX_TACK_COUNT) then
        begin
          fromIndexToIndex[1] := i;
          try
            if not hasTempRecoResult then
            begin
              actualRecoResult := tempRecoResults;
            end;
            fromIndexToIndex[2]:= fromIndexToIndex[2] +1; //Seitenzähler
            BuildTack(actualRecoResult,Switch_Sep_UserExit_Move_Halt,BlobList,fromIndexToIndex,SHOW_DOCS);
            hasTempRecoResult := false;
          except
            exit;
          end;
		  
          //Wenn die Anzahl bis zur letzten Seite nicht mehr der Anzahl der Heftung entspricht und in die Rückstellung verschoben werden soll
          //dann leg den Schalter um
          if ((ListSize - fromIndexToIndex[1]) < FIX_TACK_COUNT) AND (MOVE_FAILED_DOCS_TO_RESERVE = True) then
            moveMode := True;

          tempDocCount        := 0;
          fromIndexToIndex[0] := i+1;
        end
        else if moveMode = True then
        begin
          ccApplication.ChangeBlob(BlobList[i],ccQS_OnHold,'');
        end;
        inc(tempDocCount);

        // ------- Prüfung ob ESC gedrückt worden ist -------------------------------
        If ccRecognition.Stop Then
        Begin
          ccApplication.ShowStatus('User has stopped the execution (ESC)','Exit...',0);
          Exit;
        End;
      end;
      ccApplication.UnSelectAllBlobs(ccWS_Stack);
    end;
  finally
    ccApplication.CloseStatus;
  end;
end;