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

#include <vcl.h>
#pragma hdrstop

#include "UdTransferHistory.h"
#include "UdTransfer.h"
#include "DataModule.h"
#include <dateutils.hpp>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "Grids_ts"
#pragma link "TSDBGrid"
#pragma link "TSGrid"
//#pragma link "PERFGRAP"
#pragma link "AdvPageControl"
#pragma link "AdvGrid"
#pragma link "BaseGrid"
#pragma link "DBAdvGrd"
#pragma link "AdvGrid"
#pragma link "BaseGrid"
#pragma resource "*.dfm"
TUdTransferHistoryForm *UdTransferHistoryForm;

namespace
{
    AnsiString GetDurationString( const TDateTime & now, const TDateTime & then )
    {
        AnsiString duration;
        AnsiString text;

        // Longest duration should be in days

        int days        = DaysBetween( now, then );
        __int64 hours   = HoursBetween( now, then );
        __int64 mins    = MinutesBetween( now, then );
        __int64 secs    = SecondsBetween( now, then );

        if( days > 0 )
        {
            text.sprintf( "%d day(s), ", days );
            duration = text;
            hours = hours % 24;
            mins = mins % 60;
            secs = secs % 60;
        }
        else if( hours > 0 )
        {
            mins = mins % 60;
            secs = secs % 60;
        }
        else if( mins > 0 )
        {
            secs = secs % 60;
        }

        text.sprintf( "%02Ld:%02Ld:%02Ld", hours, mins, secs );
        duration += text;

        return duration;
    }

    AnsiString GetDurationString( const int & duration )
    {
        TDateTime then = 0;
        TDateTime now  = (double)duration/(24*60*60);
        return GetDurationString( now, then );
    }

    AnsiString FormatNumeric( long double number, int precision = 0 )
    {
        return AnsiString::FloatToStrF((long double)number, AnsiString::sffNumber, 18, precision);
    }

    typedef enum
    {
        COL_ATTRIB      = 1,
        COL_VALUE       = 2

    } TransferDetailsColumns;

    typedef enum
    {
        ROW_SOURCE_PATH = 1,
        ROW_DESTINATION = 2,
        ROW_BATCH_SIZE  = 3,
        ROW_END_TIME    = 4,
        ROW_COMMENTS    = 5,
        ROW_RAMP_TYPE   = 6,
        ROW_RAMP_TIME   = 7,
        ROW_DURATION    = 8,
        ROW_FREQUENCY   = 9,
        ROW_GRADIENT    = 10,
        ROW_RECURRING   = 11

    } TransferDetailsRows;
}

//---------------------------------------------------------------------------
__fastcall TUdTransferHistoryForm::TUdTransferHistoryForm(TComponent* Owner)
    : TForm(Owner), m_manager( NULL )
{
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::btAddClick(TObject *Sender)
{
    if( UdTransferForm->ShowForm( m_manager ) == mrOk )
    {
        RefreshHistory();
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::btnAbortClick(TObject *Sender)
{
    if( MessageDlg("Are you sure you want to abort this transfer task?",
            mtConfirmation, TMsgDlgButtons() << mbNo << mbYes, 0 ) == mrYes )
    {
        UdTransferTask task;
        task.id = m_curTransferNum;

        if( m_manager->GetTaskDetails( task ) )
        {
            AnsiString comment;
            int status = gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger;

            task.state = UdTransferAborted;
            if( status == UdTransferPending )
            {
                comment = "Transfer aborted before processing started.";
            }
            else if( status == UdTransferInProgress )
            {
                if( !task.recurring )
                {
                    comment = "Transfer aborted during processing.";
                }
                else
                {
                    // Stopping a recurring task is not really an error
                    
                    comment = "User stopped recurring transfers during processing.";
                    task.state = UdTransferCompleted;
                }
            }

            m_manager->UpdateTask( task, comment );
        }
        else
        {
            // Only way this could happen is if we are aborting a task set as
            // in progress after which the program crashed. Simply update the status flag.

            TADOQuery * txnquery = new TADOQuery(NULL);
            if( txnquery == NULL ) return;

            txnquery->Connection = Data_Module->IntegrationDBConnection;

            AnsiString sql_statement;
            sql_statement.sprintf("update TRANSFER_HISTORY set "
                                  "       STATUS = %d, "
                                  "       END_TIME = sysdate "
                                  "where  TRANSFER_NO = %d",
                                  (int)UdTransferAborted,
                                  m_curTransferNum);
            txnquery->SQL->Text = sql_statement;
            txnquery->ExecSQL();
            txnquery->Close();
            delete txnquery;

            RefreshHistory();
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::gridHistoryCellLoaded(
      TObject *Sender, int DataCol, Variant &DataRow, Variant &Value)
{
    // Format some of the loaded grid data

    if( DataCol == 5 ) // Status
    {
        switch( gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger )
        {
        case UdTransferCompleted:   Value = "Completed";        break;
        case UdTransferFailed:      Value = "Failed";           break;
        case UdTransferAborted:     Value = "Aborted";          break;
        case UdTransferInProgress:  Value = "In Progress";      break;
        case UdTransferPending:     Value = "Pending";          break;
        };
    }
}

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

void __fastcall TUdTransferHistoryForm::gridHistoryRowChanged(
      TObject *Sender, Variant &OldRow, Variant &NewRow)
{
    m_curTransferNum = gridHistory->DataSource->DataSet->FieldByName("transfer_no")->AsInteger;

    LoadTransferDetails();
    LoadTransferStatistics();

    try {
        bool isOwner = (gridHistory->DataSource->DataSet
            ->FieldByName("username")->AsString == m_manager->GetUsername());

        switch( gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger )
        {
        case UdTransferCompleted:
        case UdTransferFailed:
        case UdTransferAborted:
            btnAbort->Enabled = false;
            break;

        case UdTransferInProgress:
        case UdTransferPending:
            btnAbort->Enabled = isOwner;
            break;
        };
    }
    catch( EDatabaseError & e )
    {
        btnAbort->Enabled = false;
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::ShowForm(TObject *Sender)
{
    btnAbort->Enabled = false;
    m_curTransferNum = 0;
    
    gridDetails->Cells[COL_ATTRIB][ROW_SOURCE_PATH] = "Source Path";
    gridDetails->Cells[COL_ATTRIB][ROW_DESTINATION] = "Destination";
    gridDetails->Cells[COL_ATTRIB][ROW_BATCH_SIZE]  = "Batch Size";
    gridDetails->Cells[COL_ATTRIB][ROW_END_TIME]    = "End Time";
    gridDetails->Cells[COL_ATTRIB][ROW_COMMENTS]    = "Comments";
    gridDetails->Cells[COL_ATTRIB][ROW_RAMP_TYPE]   = "Ramp Type";
    gridDetails->Cells[COL_ATTRIB][ROW_RAMP_TIME]   = "Ramp Time";
    gridDetails->Cells[COL_ATTRIB][ROW_DURATION]    = "Duration";
    gridDetails->Cells[COL_ATTRIB][ROW_FREQUENCY]   = "Frequency";
    gridDetails->Cells[COL_ATTRIB][ROW_GRADIENT]    = "Ramp Gradient";
    gridDetails->Cells[COL_ATTRIB][ROW_RECURRING]   = "Recurring Test";

    qryTransferHistory->Active = true;
    gridHistory->DataSource = dsTransferHistory;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::LoadTransferDetails()
{
    // Get the data and load the new entries

    TADOQuery * txnquery = new TADOQuery(NULL);
    if( txnquery == NULL ) return;

    txnquery->Connection = Data_Module->IntegrationDBConnection;

    AnsiString sql_statement;
    sql_statement.sprintf("select SOURCE_PATH, DESTINATION, BATCH_SIZE, END_TIME, COMMENTS, "
                          "       RAMP_TYPE, RAMP_TIME, DURATION, FREQUENCY, RAMP_GRADIENT, RECURRING "
                          "from   TRANSFER_HISTORY "
                          "where  TRANSFER_NO = %d",
                          m_curTransferNum);
    txnquery->SQL->Text = sql_statement;
    txnquery->Open();

    if( !txnquery->Eof )
    {
        UdTransferTask task;
        AnsiString comments;
        TDateTime endTime;

        task.sourcePath     = txnquery->FieldByName("SOURCE_PATH")->AsString;
        task.destination    = txnquery->FieldByName("DESTINATION")->AsString;
        task.batchSize      = txnquery->FieldByName("BATCH_SIZE")->AsInteger;
        endTime             = txnquery->FieldByName("END_TIME")->AsDateTime;
        comments            = txnquery->FieldByName("COMMENTS")->AsString;
        task.rampType       = (RampTestType)txnquery->FieldByName("RAMP_TYPE")->AsInteger;
        task.rampTime       = txnquery->FieldByName("RAMP_TIME")->AsDateTime;
        task.duration       = txnquery->FieldByName("DURATION")->AsInteger;
        task.frequency      = txnquery->FieldByName("FREQUENCY")->AsInteger;
        task.gradient       = txnquery->FieldByName("RAMP_GRADIENT")->AsFloat;
        task.recurring      = (txnquery->FieldByName("RECURRING")->AsInteger > 0);

        SetTransferDetails( task, endTime, comments );
    }

    delete txnquery;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::ResetTransferDetails()
{
    gridDetails->ClearCols( 3, 1 );
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::ResetTransferStatistics()
{
    bool isTransferRunning = false;

    if( (m_curTransferNum != 0) &&
         gridHistory->DataSource->DataSet->Active )
    {
        int status = gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger;
        isTransferRunning = ((status == UdTransferInProgress) ||
                             (status == UdTransferPending));
    }

    lblNumFiles->Caption    = "N/A";
    lblBytes->Caption       = "N/A";
    lblTransferTime->Caption= "N/A";
    lblFilesPerSec->Caption = "N/A";
    lblBytesPerSec->Caption = "N/A";

    lblPercent->Caption     = "0%";
    pbCompleted->Position   = 0;

    lblPercent->Visible     = isTransferRunning;
    pbCompleted->Visible    = isTransferRunning;
    lblProgress->Visible    = isTransferRunning;

    seriesBatches->Clear();
    chartBatchSize->LeftAxis->Automatic = false;
    chartBatchSize->BottomAxis->Automatic = false;
    chartBatchSize->LeftAxis->SetMinMax( 0, 10 );
    chartBatchSize->BottomAxis->SetMinMax( 1, 10 );
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::SetTransferDetails( const UdTransferTask & task,
                                                            const TDateTime & endTime,
                                                            const AnsiString & comments )
{
    ResetTransferDetails();

    gridDetails->Cells[COL_VALUE][ROW_SOURCE_PATH]  = task.sourcePath;
    gridDetails->Cells[COL_VALUE][ROW_DESTINATION]  = task.destination;
    gridDetails->Cells[COL_VALUE][ROW_BATCH_SIZE]   = task.batchSize;
    gridDetails->Cells[COL_VALUE][ROW_COMMENTS]     = comments;
    gridDetails->Cells[COL_VALUE][ROW_DURATION]     = GetDurationString( task.duration );
    gridDetails->Cells[COL_VALUE][ROW_FREQUENCY]    = GetDurationString( task.frequency );

    gridDetails->Cells[COL_VALUE][ROW_END_TIME] =
        ((int)endTime == 0) ? "Not Finished" : endTime.DateTimeString().c_str();

    gridDetails->Cells[COL_VALUE][ROW_RAMP_TIME] =
        (task.rampType == RampTestDisabled) ? "Not Applicable" : task.rampTime.DateTimeString().c_str();

    gridDetails->Cells[COL_VALUE][ROW_GRADIENT] =
        (task.rampType == RampTestByDemand) ? FloatToStr(task.gradient).c_str() : "Not Applicable";

    gridDetails->Cells[COL_VALUE][ROW_RECURRING] =
        (task.recurring ? "True" : "False");

    AnsiString rampType = "Unknown";

    switch( task.rampType )
    {
    case RampTestDisabled:  rampType = "Batch Transfer";   break;
    case RampTestByDemand:  rampType = "Ramp by Demand";   break;
    case RampTestByRatio:   rampType = "Ramp by Ratio";    break;
    }
    gridDetails->Cells[COL_VALUE][ROW_RAMP_TYPE] = rampType;

}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::LoadTransferStatistics()
{
    ResetTransferStatistics();
    UpdateTransferStatistics();
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::UpdateTransferStatistics()
{
    UdTransferStatistics stats;
    if( m_manager->GetTaskStatistics( m_curTransferNum, stats ) )
    {
        int percentDone = 0;
        bool displayDurations = true;

        // If the task is pending, duration statistics are not valid yet

        try
        {
            int status = gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger;
            if( status == UdTransferPending )
            {
                lblTransferTime->Caption = "Pending ...";
                displayDurations = false;
            }
        }
        catch( EDatabaseError & e )
        {
            displayDurations = false;
        }

        // Set processed/total files stats

        if( stats.completed )
        {
            lblNumFiles->Caption = FormatNumeric( stats.processedFiles );
            lblBytes->Caption = FormatNumeric( stats.processedBytes );

            displayDurations = (stats.processedFiles > 0);
        }
        else if( stats.totalFiles > 0 )
        {
            // Stats provided in realtime (non-complete) have more info to display

            lblBytes->Caption = FormatNumeric( stats.processedBytes );
            lblNumFiles->Caption = FormatNumeric( stats.processedFiles % stats.totalFiles )
                + " / " + FormatNumeric( stats.totalFiles );

            if( stats.processedFiles > stats.totalFiles )
            {
                AnsiString recurses = lblNumFiles->Caption;
                recurses += " (x" + IntToStr( stats.processedFiles / stats.totalFiles ) + ")";
                lblNumFiles->Caption = recurses;
            }

            if( gridDetails->Cells[COL_VALUE][ROW_RECURRING] != "True" )
            {
                percentDone = (((stats.processedFiles % stats.totalFiles)*100) / stats.totalFiles);
            }
        }

        // Fill in the chart details

        if( !stats.batches.empty() )
        {
            seriesBatches->Clear();
            chartBatchSize->LeftAxis->Automatic = true;
            chartBatchSize->BottomAxis->Automatic = true;

            BatchSizeItem batch = stats.batches.begin();
            for( int count = 1; batch != stats.batches.end(); batch++, count++ )
            {
                seriesBatches->AddXY( count, (double)(*batch)/1024, "", clBlue );
            }
        }

        // Dont display durations for transfers with no files sent

        if( displayDurations )
        {
            try {
                TDateTime startTime = stats.startTime;
                TDateTime endTime = TDateTime::CurrentDateTime();
                if( stats.completed ) endTime = gridDetails->Cells[COL_VALUE][ROW_END_TIME];

                lblTransferTime->Caption = GetDurationString( endTime, startTime );
                __int64 duration = SecondsBetween( endTime, startTime );

                if( duration > 0 )
                {
                    lblFilesPerSec->Caption = FormatNumeric( (double)stats.processedFiles / duration, 3 );
                    lblBytesPerSec->Caption = FormatNumeric( (double)stats.processedBytes / duration, 3 );
                }
                else
                {
                    lblFilesPerSec->Caption = FormatNumeric( (double)stats.processedFiles, 3 );
                    lblBytesPerSec->Caption = FormatNumeric( (double)stats.processedBytes, 3 );
                }

                if( !stats.completed )
                {
                    __int64 completion = SecondsBetween( stats.endTime, startTime );
                    if( completion > 0 )
                    {
                        if( duration > completion )
                        {
                            percentDone = 100;
                        }
                        else
                        {
                            int timePercent = (((duration % completion)*100) / completion);
                            if( timePercent > percentDone )
                            {
                                percentDone = timePercent;
                            }
                        }
                    }
                }
            }
            catch( EConvertError & e )
            {
                // If we're here, it means we have a case where we are accessing
                // an in-progress task after a program crash (end time will fail to convert
                // as it is just text). We wont know the end time in anycase, so just
                // ignore it and display "N/A"s.
            }
            catch( EDatabaseError & e ) {} // Ignore
        }

        // Set the progress bar if required. Take the max between files remaining
        // (if not recurring task), and the time remaining till completion.

        if( !stats.completed )
        {
            if( percentDone > 100 ) percentDone = 100;

            lblPercent->Caption = IntToStr( percentDone ) + "%";
            pbCompleted->Position = percentDone;
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::gridRowResized(
      TObject *Sender, int RowColnr)
{
    // Ensure row height is not less than the font size

    int minHistoryRowSize = (gridHistory->Font->Size + 5);
    if( gridHistory->DefaultRowHeight < minHistoryRowSize )
    {
        gridHistory->DefaultRowHeight = minHistoryRowSize;
    }

    int minDetailsRowSize = (gridDetails->Font->Size +5);
    if( gridDetails->DefaultRowHeight < minDetailsRowSize )
    {
        gridDetails->DefaultRowHeight = minDetailsRowSize;
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::btnCloseClick(TObject *Sender)
{
    Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::btnRefreshClick(TObject *Sender)
{
    RefreshHistory();
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::TimerTick(TObject *Sender)
{
    if( (tabDetails->ActivePageIndex == 1) &&
        qryTransferHistory->Active )
    {
        int status = gridHistory->DataSource->DataSet->FieldByName("status")->AsInteger;
        if( (status == UdTransferPending || status == UdTransferInProgress) )
        {
            UpdateTransferStatistics();
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferHistoryForm::RefreshHistory()
{
    qryTransferHistory->Active = false;
    qryTransferHistory->Active = true;
/*
    if( gridHistory-> )
    {
        gridHistory->CurrentCell->MoveTo( 1, 1 );
    }

    LoadTransferDetails();
    LoadTransferStatistics();
*/
}