{*******************************************************}
{                                                       }
{       AppHookClient                                   }
{                                                       }
{       Copyright (C) 2023 kku                          }
{                                                       }
{*******************************************************}

unit AppHookClient;

interface

uses
  Tocsg.ClientBase, System.Classes, WinApi.Windows, Tocsg.Packet,  superobject,  GlobalDefine,
  System.SysUtils;

type
  TAppHookClient = class(TTgClientBase)
  protected
    dwPid_,
    dwLastSaveTick_: DWORD;
    sModulePath_: String;
    evDisconnected_: TNotifyEvent;
    procedure ConnectedEvent; override;
    procedure DisconnectedEvent; override;
    procedure ProcessRcvPacket(aRcv: IRcvPacket); override;
  public
    Constructor Create;

    property ModulePath: String write sModulePath_;
    property OnDisconnected: TNotifyEvent write evDisconnected_;
  end;


  function ParseBlockFileNew(const ANode: ISuperObject; const ACurrentTarget: TIntBlockNewFile): TIntBlockNewFile;

implementation

uses
{$IFDEF _BS1HP_}
  BS1Hook,
{$ELSE}
  AppHook,
{$ENDIF}
  Tocsg.Exception, Tocsg.Process, Tocsg.WndUtil,
  AppCtrlDefine, Tocsg.Json;



function ParseBlockFileNew(const ANode: ISuperObject; const ACurrentTarget: TIntBlockNewFile): TIntBlockNewFile;
begin
  Result := ACurrentTarget;

  if ANode = nil then
    Exit;

  Result.mode := TAttachBlockKind(ANode.I['mode']);
  Result.userAlert := ANode.B['userAlert'];
  Result.extList := ANode.S['extList'];
  Result.excList := ANode.S['excList'];
  Result.origTextCol := ANode.B['origTextCol'];
  Result.origFileCol_use := ANode.B['origFileCol_use'];
  Result.origFileCol_maxMb := ANode.I['origFileCol_maxMb'];
  Result.origFileCol_minMb := ANode.I['origFileCol_minMb'];
  Result.fileNameChk := ANode.B['fileNameChk'];
  Result.contentsFilter_use := ANode.B['contentsFilter_use'];
  Result.blockByFilename_use := ANode.B['blockByFilename_use'];
  Result.blockByFilename_list := ANode.S['blockByFilename_list'];
  Result.blockBySig_use := ANode.B['blockBySig_use'];
  Result.blockBySig_list := ANode.S['blockBySig_list'];
  Result.blockBySizeLimit_use := ANode.B['blockBySizeLimit_use'];
  Result.blockBySizeLimit_minMb := ANode.I['blockBySizeLimit_minMb'];
end;

  { TAppHookClient }

Constructor TAppHookClient.Create;
begin
  Inherited Create('', -1);
//  FreeOnTerminate := true;
  @evDisconnected_ := nil;
  dwPid_ := GetCurrentProcessId;
  dwLastSaveTick_ := 0;
end;

procedure TAppHookClient.ConnectedEvent;
var
  Send: ISendPacket;
begin
  try
//    Inherited;
    SetSendPauseState(false);
    _Trace('Connected.');

    Send := TTgPacket.Create(ACC_APP_INFO);
    Send.I['PID'] := dwPid_;
    Send.S['Path'] := sModulePath_;
    SendPacket(Send);
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. ConnectedEvent()');
  end;
end;

procedure TAppHookClient.DisconnectedEvent;
begin
  try
    Inherited;
    QSendPacket_.Clear;

    if Assigned(evDisconnected_) then
      evDisconnected_(Self);

    _Trace('Disconnected');
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. DisconnectedEvent()');
  end;
end;

procedure TAppHookClient.ProcessRcvPacket(aRcv: IRcvPacket);
var
  Send: ISendPacket;

  procedure process_ACC_TEST_LOG;
  begin
    _Trace(aRcv.S['Msg']);

    Send := TTgPacket.Create(aRcv);
    Send.S['Msg'] := aRcv.S['Msg'] + ' 하하하';
    SendPacket(Send);
  end;

  procedure process_ACC_SET_POLICY;
  var
    Opt: TAppCtrlOpt;
  begin
    try
      if aRcv.O['Opt'] = nil then
        exit;

      ZeroMemory(@Opt, SizeOf(Opt));
      with aRcv.O['Opt'] do
      begin
        Opt.sTaskDir := S['sTaskDir'];
        Opt.dwCustomerType := I['dwCustomerType'];
        Opt.hMainWnd := I['hMainWnd'];

      // DRM
        Opt.DrmAccessKind := TDrmAccessKind(I['DrmAccessKind']);
        Opt.DrmModifyKind := TDrmAccessKind(I['DrmModifyKind']);
        Opt.bDrmAttachAble := B['bDrmAttachAble'];
        Opt.sDrmPass := S['sDrmPass'];
        Opt.sUName := S['sUName'];
        Opt.sEmpNo := S['sEmpNo'];
        Opt.sDeptName := S['sDeptName'];
        Opt.sIpAddr := S['sIpAddr'];

      // Print
        Opt.nFontSize := I['nFontSize'];
        Opt.nLineCount := I['nLineCount'];
//        Opt.sTextOutApp := S['sTextOutApp'];
//        Opt.sTextOutDir := S['sTextOutDir'];
        Opt.sPrtEmfOutDir := S['sPrtEmfOutDir'];
        Opt.sPrintWaterImg := S['sPrintWaterImg'];
        Opt.nPrintWaterAlpha := I['nPrintWaterAlpha'];
//        Opt.sPrintWaterTxt := S['sPrintWaterTxt'];
        Opt.bPrintSecu := B['bPrintSecu'];
        Opt.bPrintWater := B['bPrintWater'];
        Opt.bPrtCollect := B['bPrtCollect'];
        Opt.sPrintWaterExp := S['sPrintWaterExp'];
        Opt.fWmTran := D['fWmTran'];
//        Opt.bPrintMasking := B['bPrintMasking'];
        try
          Opt.PrtWaterCfg := TTgJson.GetDataAsType<TPrtWaterCfg>(O['PrtWaterCfg']);
        except
          ZeroMemory(@Opt.PrtWaterCfg, SizeOf(Opt.PrtWaterCfg));
        end;

      // File
        Opt.FileUseBlock := TFileUseBlock(I['FileUseBlock']);
        Opt.bCheckUrl := B['bCheckUrl'];
        Opt.bUseContentFilter := B['bUseContentFilter'];
        Opt.bReadBlock := B['bReadBlock'];
        Opt.bWriteBlock := B['bWriteBlock'];
        Opt.bFileApproval := B['bFileApproval'];
        Opt.bIgrNetPathAB := B['bIgrNetPathAB'];
        Opt.bOpenDetect := B['bOpenDetect'];
        if O['ShFileCrMon'] <> nil then
        begin
          Opt.ShFileCrMon.nKind := O['ShFileCrMon'].I['nKind'];
          Opt.ShFileCrMon.bBlkNoti := O['ShFileCrMon'].B['bBlkNoti'];
          Opt.ShFileCrMon.bMonNoti := O['ShFileCrMon'].B['bMonNoti'];
          Opt.ShFileCrMon.sExpLst := O['ShFileCrMon'].S['sExpLst'];
        end else
          Opt.ShFileCrMon.nKind := 0;
        Opt.nBlockSizeMB := I['nBlockSizeMB'];

      // Noti
        Opt.hRcvWnd := I['hRcvWnd'];
        Opt.hTagWnd := I['hTagWnd'];
        Opt.hCltWnd := I['hCltWnd'];

      // ETC
        Opt.sAcName := S['sAcName'];
        Opt.sAcSSid := S['sAcSSid'];
        Opt.sAipPath := S['sAipPath'];
        Opt.bMtpWB := B['bMtpWB'];
        Opt.sMtpRoExp := S['sMtpRoExp'];
        Opt.bIsTest := B['bIsTest'];

        //USB, Bluetooth, UsbToUsb
        Opt.IntBtBlockNewFile       := ParseBlockFileNew(O['IntBtBlockNewFile'],       Opt.IntBtBlockNewFile);
        Opt.IntUsbBlockNewFile      := ParseBlockFileNew(O['IntUsbBlockNewFile'],      Opt.IntUsbBlockNewFile);
        Opt.IntUsbToUsbBlockNewFile := ParseBlockFileNew(O['IntUsbToUsbBlockNewFile'], Opt.IntUsbToUsbBlockNewFile);
        Opt.IntCdromBlockNewFile    := ParseBlockFileNew(O['IntCdromBlockNewFile'],    Opt.IntCdromBlockNewFile);
        Opt.IntMtpBlockNewFile      := ParseBlockFileNew(O['IntMtpBlockNewFile'],      Opt.IntMtpBlockNewFile);

      end;
//      Opt := TTgJson.GetDataAsType<TAppCtrlOpt>(aRcv.O['Opt']);

      gAppHook.ProcessAppCtrlOpt(Opt);
    except
    //
    end;
  end;

  procedure process_ACC_SAFE_TERMINATE_CLIENT;
  begin
    gAppHook.DoInterceptRemove;
    Disconnect;
    Sleep(3000);
//    StopThread;
  end;

  procedure process_ACC_SET_CAPTURE_BLOCK;
  begin
  {$IFDEF _BS1HP_}
    if gAppHook <> nil then
    begin
      if aRcv.B['Block'] then
        gAppHook.AddCapBlockWnd(aRcv.I['Wnd'])
      else
        gAppHook.DelCapBlockWnd(aRcv.I['Wnd']);
    end;
  {$ENDIF}
  end;

  procedure process_ACC_GOODBYE;
  begin
  // madCodeHook에서 DLL 해제 할때 FreeAndNil(Client_), FreeAndNil(Helper_) 여기서 헹걸리는데
  // 아래 처럼 개선 25_0107 21:59:49 kku
    StopThread;
  {$IFDEF _BS1HP_}
    if gAppHook <> nil then
      gAppHook.ProcessGoodbye;
  {$ENDIF}
    Sleep(1000);
  end;

begin
  try
    case aRcv.Command of
      ACC_TEST_LOG              : process_ACC_TEST_LOG;
      ACC_SET_POLICY            : process_ACC_SET_POLICY;
      ACC_SAFE_TERMINATE_CLIENT : process_ACC_SAFE_TERMINATE_CLIENT;
      ACC_SET_CAPTURE_BLOCK     : process_ACC_SET_CAPTURE_BLOCK;
      ACC_GOODBYE               : process_ACC_GOODBYE;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. ProcessRcvPacket(), Cmd=%d', [aRcv.Command]);
  end;
end;

end.