#require "xhb"
#include "box.ch"
#include "fileio.ch"

REQUEST HB_CODEPAGE_PTISO

STATIC nCopiados := 0
STATIC nTotalBytes := 0

FUNCTION Main()  //testcopyFile

   //LOCAL cFile := 'Vídeos C#.rar'
   //local cSource := hb_dirbase() + cFile
   LOCAL cSource := PadR("C:\Users\santosa\Desktop\Vídeos C#.rar",255)
   //local cTarget := 'backup\' + cFile
   LOCAL cTarget := PadR('Vídeos C#.rar',255)

   LOCAL lCopy
    
   LOCAL cStart, nHandle
   LOCAL GetList := {}
                                                                           
   HB_CDPSELECT("PTISO")
   Set( _SET_DATEFORMAT, "dd/mm/yyyy" )   
   SetMode(25,80)   
   SetBlink( .F. )
   SetColor( "N/W, N/W*" )


   CLS
   
   @2,1 SAY PadC( "Teste File Copy", 78 ) COLOR "W+/N*"
   DispBox( 3, 1, 23, 78, B_SINGLE + " " )
   
   DispBox( 4, 2, 08, 77, B_SINGLE + " " )
   DispBox( 9, 2, 19, 77, B_SINGLE + " " )
         
   @05, 3 SAY "Origem :" GET cSource PICT "@S64"
   @07, 3 SAY "Destino:" GET cTarget PICT "@S64"

   READ
 
 Altd()

   IF (nHandle := FOPEN(cSource)) >= 0
      //
      // Get length of the file
      nTotalBytes := FSEEK(nHandle, 0, FS_END)
      //
      // Reset file position to beginning of file
      FSEEK(nHandle, 0)
      FCLOSE(nHandle)
   ELSE
      ? "File open error:", FERROR()
      QUIT
   ENDIF

 
   cStart := Time()
 
   lCopy := __XHB_COPYFILE(RTrim(cSource), RTrim(cTarget), {| x | ShowCopy( x ) }) // Every 8192 Bytes copied
 
   /* ==> Alterei isso: Clipper returns .F. on failure and .T. on success */
 
   IF lCopy
      Alert('Copy done ... ' + ElapTime( cStart, Time() ) + " segundos" )
   ELSE
     Alert('Copy failed')
   ENDIF

RETURN NIL

//---------------------------------------------------------------------------------------------------------------
FUNCTION ShowCopy(x)

   IF nCopiados == NIL
      nCopiados := 0
   endif
   
   nCopiados += x
 
   @ MaxRow(),1 say ' Copying: ' + str(nCopiados) + ' of ' + str(nTotalBytes)
RETURN NIL

//---------------------------------------------------------------------------------------------------------------

#pragma BEGINDUMP

#include "hbapi.h"
#include "hbapierr.h"
#include "hbapifs.h"
#include "hbapiitm.h"
#include "hbvm.h"

#if defined( HB_OS_UNIX )
   #include <sys/stat.h>
   #include <unistd.h>
#endif

#ifdef HB_CLP_STRICT
   #define BUFFER_SIZE  8192
#else
   #define BUFFER_SIZE  65536   
#endif

static HB_BOOL __hb_copyfile( const char * szSource, const char * szDest, PHB_ITEM pBlock )
{
   HB_BOOL    bRetVal = HB_FALSE;
   HB_FHANDLE fhndSource;
   PHB_ITEM pError = NULL;

   HB_TRACE( HB_TR_DEBUG, ( "__hb_copyfile(%s, %s)", szSource, szDest ) );

   do
   {
      fhndSource = hb_fsExtOpen( szSource, NULL,
                                 FO_READ | FXO_DEFAULTS | FXO_SHARELOCK,
                                 NULL, pError );
      if( fhndSource == FS_ERROR )
      {
         pError = hb_errRT_FileError( pError, NULL, EG_OPEN, 2012, szSource );
         if( hb_errLaunch( pError ) != E_RETRY )
            break;
      }
   }
   while( fhndSource == FS_ERROR );

   if( fhndSource != FS_ERROR )
   {
      HB_FHANDLE fhndDest;

      do
      {
         fhndDest = hb_fsExtOpen( szDest, NULL,
                                  FXO_TRUNCATE | FO_READWRITE | FO_EXCLUSIVE |
                                  FXO_DEFAULTS | FXO_SHARELOCK,
                                  NULL, pError );
         if( fhndDest == FS_ERROR )
         {
            pError = hb_errRT_FileError( pError, NULL, EG_CREATE, 2012, szDest );
            if( hb_errLaunch( pError ) != E_RETRY )
               break;
         }
      }
      while( fhndDest == FS_ERROR );
      
      if( fhndDest != FS_ERROR )
      {
         #if defined( HB_OS_UNIX )
            struct stat struFileInfo;
            int         iSuccess = fstat( fhndSource, &struFileInfo );
         #endif
         
         void * buffer;
         HB_SIZE nRead;

         buffer = hb_xgrab( BUFFER_SIZE );

         bRetVal = HB_TRUE;

         if( hb_itemType( pBlock ) != HB_IT_BLOCK )
            pBlock = NULL;

         while( ( nRead = hb_fsReadLarge( fhndSource, buffer, BUFFER_SIZE ) ) != 0 )
         {
            while( hb_fsWriteLarge( fhndDest, buffer, nRead ) != nRead )
            {
               pError = hb_errRT_FileError( pError, NULL, EG_WRITE, 2016, szDest );
               if( hb_errLaunch( pError ) != E_RETRY )
               {
                  bRetVal = HB_FALSE;
                  break;
               }
            }

            if( pBlock )
            {
               PHB_ITEM pCnt = hb_itemPutNL( NULL, nRead );

               hb_vmEvalBlockV( pBlock, 1, pCnt );

               hb_itemRelease( pCnt );
            }
         }

         hb_xfree( buffer );

         #if defined( HB_OS_UNIX )
            if( iSuccess == 0 )
               fchmod( fhndDest, struFileInfo.st_mode );
         #endif

         hb_fsClose( fhndDest );
      }

      hb_fsClose( fhndSource );
   }

   if( pError )
      hb_itemRelease( pError );
   return bRetVal;
}

/* Clipper returns .F. on failure and NIL on success */

HB_FUNC( __XHB_COPYFILE )
{
   if( HB_ISCHAR( 1 ) && HB_ISCHAR( 2 ) )
   {
      if( ! __hb_copyfile( hb_parc( 1 ), hb_parc( 2 ), hb_param( 3, HB_IT_BLOCK ) ) )
         hb_retl( HB_FALSE );
      else
         hb_retl( HB_TRUE );            
   }
   else
      hb_errRT_BASE( EG_ARG, 2010, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );  
      /* NOTE: Undocumented but existing Clipper Run-time error */
}

#pragma ENDDUMP
//---------------------------------------------------------------------------------------------------------------