#include "hbclass.ch"

REQUEST HB_GT_STD_DEFAULT

CREATE CLASS TFakeConectorDatos

   DATA hVariables INIT { => }
   DATA hData INIT { => }

   METHOD New( hVariables, hData ) CONSTRUCTOR
   METHOD GetVariables()
   METHOD GetData()

ENDCLASS

METHOD New( hVariables, hData ) CLASS TFakeConectorDatos

   ::hVariables := iif( HB_ISHASH( hVariables ), hVariables, { => } )
   ::hData := iif( HB_ISHASH( hData ), hData, { => } )

RETURN Self

METHOD GetVariables() CLASS TFakeConectorDatos

RETURN ::hVariables

METHOD GetData() CLASS TFakeConectorDatos

RETURN ::hData

PROCEDURE Main()

   LOCAL oConector
   LOCAL oEvaluador
   LOCAL oContexto
   LOCAL hOpciones
   LOCAL hVariables
   LOCAL hCondicion
   LOCAL hPlan
   LOCAL hEvaluacion
   LOCAL nFailures := 0

   InstallConsoleErrorHandler()

   oConector := TFakeConectorDatos():New( { ;
      "CLIENTE" => "Dulces Valero", ;
      "TOTAL" => 100, ;
      "OMEMQUERY.CANTIDAD" => 1, ;
      "OMEMQUERY.IVA" => 10, ;
      "OMEMQUERY.CONCEPTO" => "ARTICULO PRUEBA", ;
      "OMEMQUERY.tipodoc" => "VALOR OBSOLETO", ;
      "LINEAS_FACTURA.TOTAL_LINEA" => 0 }, ;
      { "origen" => "test" } )

   oEvaluador := TEvaluadorFormulas():New():Create()
   hOpciones := { ;
      "nPaginaActualRuntime" => 2, ;
      "nTotalPaginasRuntime" => 5, ;
      "nRegistroBase" => 10, ;
      "modoEjecucion" => "real", ;
      "aDataVarChangesRuntime" => { ;
         { "nIndiceDetalle" => 0, "hVariables" => { "CABECERA.RUPTURA" => "A" } }, ;
         { "nIndiceDetalle" => 12, "hVariables" => { "CABECERA.RUPTURA" => "B" } }, ;
         { "nIndiceDetalle" => 12, "hVariables" => { "CABECERA.EXTRA" => "X" } } }, ;
      "hUserVars" => { ;
         "DOBLE_TOTAL" => { "formula" => "TOTAL * 2" }, ;
         "PAGINA" => { "formula" => "Page()" }, ;
         "ISNULO" => { "formula" => ".not. isNULL(OMEMQUERY.cantidad) .AND. OMEMQUERY.cantidad==0" }, ;
         "POSNULO" => { "formula" => '(At(" x ",OMEMQUERY.concepto)-1)' }, ;
         "Z_ERROR_AUXILIAR" => { "formula" => "CAMPO_QUE_NO_EXISTE" } }, ;
      "hAcumVars" => { "TOTAL_LINEAS" => { "formula" => "LINEAS_FACTURA.TOTAL_LINEA" } }, ;
      "hPaginacionPorClaveRuntime" => { "A-1" => { "aPaginas" => { 1, 2 } } } }

   oContexto := TContextoEjecucion():New( oConector, oEvaluador, hOpciones ):Create()

   hVariables := oContexto:GetVariables()
   nFailures += AssertHashValue( "Variable conector", hVariables, "CLIENTE", "Dulces Valero" )
   nFailures += AssertHashValue( "DataVar ruptura inicial", hVariables, "CABECERA.RUPTURA", "A" )
   nFailures += AssertHashValue( "VAR formula cruda", hVariables, "VAR.DOBLE_TOTAL", "TOTAL * 2" )
   nFailures += AssertHashValue( "User var evaluada", hVariables, "DOBLE_TOTAL", 200 )
   hCondicion := oContexto:EvaluarCondicionConEstado( "OMEMQUERY.IVA == 10", { "lLastPageDisponible" => .F. } )
   nFailures += AssertHashValue( "Condicion valida no hereda error auxiliar", hCondicion, "lVisible", .T. )
   nFailures += AssertHashValue( "Condicion valida queda libre de error auxiliar", hCondicion, "lError", .F. )
   nFailures += AssertHashValue( "Condicion valida sin mensaje auxiliar", hCondicion, "cError", "" )
   hEvaluacion := oContexto:EvaluarFormulaConEstado( "OMEMQUERY.IVA == 10" )
   nFailures += AssertHashValue( "Formula valida no hereda error auxiliar", hEvaluacion, "valor", .T. )
   nFailures += AssertHashValue( "Formula valida queda libre de error auxiliar", hEvaluacion, "lError", .F. )
   nFailures += AssertHashValue( "Formula valida sin mensaje auxiliar", hEvaluacion, "cError", "" )
   hPlan := oContexto:CompilarPlanFormula( 'IF(VAR.isNulo,SubStr(OMEMQUERY.concepto,VAR.posNULO+3),Transform(OMEMQUERY.iva,"@E 99")+"% "+OMEMQUERY.concepto)' )
   hEvaluacion := oContexto:EvaluarPlanFormulaConEstado( hPlan, 'IF(VAR.isNulo,SubStr(OMEMQUERY.concepto,VAR.posNULO+3),Transform(OMEMQUERY.iva,"@E 99")+"% "+OMEMQUERY.concepto)' )
   nFailures += AssertHashValue( "Concepto ticket no hereda error auxiliar", hEvaluacion, "valor", "10% ARTICULO PRUEBA" )
   nFailures += AssertHashValue( "Concepto ticket no queda marcado como error", hEvaluacion, "lError", .F. )
   nFailures += AssertHashValue( "Concepto ticket sin mensaje de error heredado", hEvaluacion, "cError", "" )
   nFailures += AssertHashValue( "Acumulador inicial", hVariables, "SUM.TOTAL_LINEAS", 0 )
   nFailures += AssertEqual( "Data conector", oContexto:GetData()[ "origen" ], "test" )
   nFailures += AssertEqual( "Page sincronizada", oContexto:EvaluarFormula( "Page()" ), 2 )
   nFailures += AssertEqual( "Pages sincronizada", oContexto:EvaluarFormula( "Pages()" ), 5 )
   nFailures += AssertHashValue( "User var de pagina", hVariables, "PAGINA", 2 )
   oContexto:SetEstadoPagina( 3, 5 )
   nFailures += AssertHashValue( "Cache invalidada por pagina", oContexto:GetVariables(), "PAGINA", 3 )
   oContexto:SetEstadoPagina( 2, 5 )
   nFailures += AssertEqual( "PageBy contexto", oContexto:EvaluarFormula( 'PageBy("A-1")' ), 2 )
   nFailures += AssertEqual( "TotalPagesBy contexto", oContexto:EvaluarFormula( 'TotalPagesBy("A-1")' ), 2 )
   oContexto:SetEstadoPagina( 5, 5 )
   nFailures += AssertEqual( "LastPage no disponible en salto de tabla", oContexto:CumpleCondicionConEstado( "LastPage()", { "lLastPageDisponible" => .F. } ), .F. )
   nFailures += AssertEqual( "LastPage restaurada tras salto de tabla", oContexto:CumpleCondicion( "LastPage()" ), .T. )
   hCondicion := oContexto:EvaluarCondicionConEstado( "LastPage()", { "lLastPageDisponible" => .F. } )
   nFailures += AssertHashValue( "Condicion con estado devuelve visibilidad", hCondicion, "lVisible", .F. )
   nFailures += AssertHashValue( "Condicion con estado valida sin error", hCondicion, "lError", .F. )
   nFailures += AssertHashValue( "Condicion con estado sin mensaje de error", hCondicion, "cError", "" )
   nFailures += AssertEqual( "Estado restaurado tras evaluacion estructurada", oContexto:CumpleCondicion( "LastPage()" ), .T. )
   hCondicion := oContexto:EvaluarCondicionConEstado( "CAMPO_QUE_NO_EXISTE > 0", { "lLastPageDisponible" => .F. } )
   nFailures += AssertHashValue( "Condicion invalida queda marcada como error", hCondicion, "lError", .T. )
   nFailures += AssertHashValue( "Condicion invalida nunca queda visible", hCondicion, "lVisible", .F. )
   nFailures += AssertEqual( "Condicion invalida conserva detalle del error", At( "Variable no encontrada", hCondicion[ "cError" ] ) > 0, .T. )
   oContexto:SetEstadoPagina( 2, 5 )

   oContexto:PushVariablesLocales( { "LOCAL_VALOR" => 7 } )
   nFailures += AssertEqual( "Variable local", oContexto:EvaluarFormula( "LOCAL_VALOR + 3" ), 10 )
   oContexto:PopVariablesLocales()

   oContexto:PushRegistroDetalle( { "LINEAS_FACTURA.TOTAL_LINEA" => 5 }, 12, 20, { => }, { => } )
   nFailures += AssertHashValue( "DataVar ruptura por indice", oContexto:GetVariables(), "CABECERA.RUPTURA", "B" )
   nFailures += AssertHashValue( "DataVar cambios del mismo indice", oContexto:GetVariables(), "CABECERA.EXTRA", "X" )
   oContexto:PopRegistroDetalle()
   oContexto:MarcarRegistroDetalleConsumido( 12 )
   nFailures += AssertHashValue( "DataVar ruptura tras detalle", oContexto:GetVariables(), "CABECERA.RUPTURA", "B" )

   oContexto:PushRegistroDetalle( ;
      { "LINEAS_FACTURA.CODCLI" => "C002", "LINEAS_FACTURA.TOTAL_LINEA" => 20.5, "OMEMQUERY.TIPODOC" => "B" }, ;
      11, ;
      20, ;
      { "LINEAS_FACTURA.CODCLI" => "C001", "OMEMQUERY.TIPODOC" => "A" }, ;
      { "LINEAS_FACTURA.CODCLI" => "C003" } )
   nFailures += AssertHashValue( "DataVar retroceso de indice", oContexto:GetVariables(), "CABECERA.RUPTURA", "A" )
   nFailures += AssertEqual( "Recno detalle", oContexto:EvaluarFormula( "Recno()" ), 12 )
   nFailures += AssertEqual( "Reccount detalle", oContexto:EvaluarFormula( "Reccount()" ), 20 )
   nFailures += AssertEqual( "Previous detalle", oContexto:EvaluarFormula( "Previous(LINEAS_FACTURA.CODCLI)" ), "C001" )
   nFailures += AssertEqual( "Registro actual sustituye alias con distinta caja", oContexto:EvaluarFormula( "OMEMQUERY.tipodoc" ), "B" )
   nFailures += AssertEqual( "Previous sustituye alias con distinta caja", oContexto:EvaluarFormula( "Previous(OMEMQUERY.tipodoc)" ), "A" )
   nFailures += AssertEqual( "Next detalle", oContexto:EvaluarFormula( "Next(LINEAS_FACTURA.CODCLI)" ), "C003" )
   oContexto:AcumularDetalle()
   nFailures += AssertHashValue( "Acumulador detalle", oContexto:GetAcumuladores(), "SUM.TOTAL_LINEAS", 20.5 )
   oContexto:ResetAcumuladoresSeleccionados( { "TOTAL_LINEAS" } )
   nFailures += AssertHashValue( "Reset acumulador seleccionado", oContexto:GetAcumuladores(), "SUM.TOTAL_LINEAS", 0 )
   oContexto:PopRegistroDetalle()

   oContexto:MarcarRegistroDetalleConsumido( 12 )
   nFailures += AssertEqual( "Registros consumidos", oContexto:GetRegistrosDetalleConsumidosRuntime(), 3 )
   hCondicion := oContexto:EvaluarCondicion( "TOTAL > 50" )
   nFailures += AssertHashValue( "Condicion contexto", hCondicion, "lVisible", .T. )
   oContexto:AddAviso( "Aviso de prueba" )
   nFailures += AssertEqual( "Avisos", Len( oContexto:GetAvisos() ), 1 )
   oContexto:DescartarObjeto( NIL, "condicion falsa" )
   nFailures += AssertEqual( "Descartados", Len( oContexto:GetDescartados() ), 1 )
   nFailures += AssertEqual( "Modo ejecucion", oContexto:GetModoEjecucion(), "real" )
   nFailures += AssertEqual( "Modo disenador", oContexto:EsModoDisenador(), .F. )

   IF nFailures == 0
      LogLine( "TContextoEjecucion Harbour OK" )
   ELSE
      LogLine( "TContextoEjecucion Harbour FAIL: " + hb_NToS( nFailures ) )
   ENDIF

   oContexto:End()
   oEvaluador:End()
   ErrorLevel( nFailures )

RETURN

FUNCTION AssertHashValue( cCaseName, hHash, cKey, uExpected )

   IF ! HB_ISHASH( hHash ) .OR. ! hb_HHasKey( hHash, cKey )
      LogLine( "FAIL " + cCaseName )
      LogLine( "  falta clave: " + cKey )
      RETURN 1
   ENDIF

RETURN AssertEqual( cCaseName, hHash[ cKey ], uExpected )

FUNCTION AssertEqual( cCaseName, uActual, uExpected )

   IF ValuesEqual( uActual, uExpected )
      RETURN 0
   ENDIF

   LogLine( "FAIL " + cCaseName )
   LogLine( "  esperado: " + hb_ValToStr( uExpected ) )
   LogLine( "  actual  : " + hb_ValToStr( uActual ) )

RETURN 1

STATIC FUNCTION ValuesEqual( uActual, uExpected )

   LOCAL cType := ValType( uExpected )

   IF ValType( uActual ) != cType
      RETURN .F.
   ENDIF

   DO CASE
   CASE cType == "U"
      RETURN .T.
   CASE cType == "N" .OR. cType == "C" .OR. cType == "L" .OR. cType == "D"
      RETURN uActual == uExpected
   CASE cType == "H" .OR. cType == "A"
      RETURN hb_ValToStr( uActual ) == hb_ValToStr( uExpected )
   ENDCASE

RETURN hb_ValToStr( uActual ) == hb_ValToStr( uExpected )

FUNCTION LogLine( cText )

   OutStd( cText + hb_eol() )

RETURN NIL

STATIC PROCEDURE InstallConsoleErrorHandler()

   ErrorBlock( {|oError| ConsoleErrorHandler( oError ) } )

RETURN

STATIC FUNCTION ConsoleErrorHandler( oError )

   LOCAL nLevel := 1

   OutErr( hb_eol() + "ERROR HARBOUR NO INTERACTIVO" + hb_eol() )
   OutErr( "SubSystem: " + hb_ValToStr( oError:SubSystem ) + hb_eol() )
   OutErr( "SubCode: " + hb_ValToStr( oError:SubCode ) + hb_eol() )
   OutErr( "Description: " + hb_ValToStr( oError:Description ) + hb_eol() )
   OutErr( "Operation: " + hb_ValToStr( oError:Operation ) + hb_eol() )
   OutErr( "Stack:" + hb_eol() )
   DO WHILE ! Empty( ProcName( nLevel ) )
      OutErr( "  " + hb_NToS( nLevel ) + ": " + ProcName( nLevel ) + "(" + hb_NToS( ProcLine( nLevel ) ) + ")" + hb_eol() )
      nLevel++
   ENDDO

   ErrorLevel( 1 )
   QUIT

RETURN NIL