// KDat - a tar-based DAT archiver
// Copyright (C) 1998-2000  Sean Vyain, svyain@mail.tds.net
// Copyright (C) 2001-2002  Lawrence Widman, kdat@cardiothink.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mtio.h>
#include <unistd.h>
#include <time.h>

#include <tqfile.h>

#include <tdemessagebox.h>
#include <tdeapplication.h>
#include <tdelocale.h>

#include "KDatMainWindow.h"
#include "Options.h"
#include "Tape.h"
#include "TapeManager.h"
#include "TapeDrive.h"
#include "kdat.h"

#include "TapeDrive.moc"

TapeDrive* TapeDrive::_instance = 0;

TapeDrive* TapeDrive::instance()
{
    if ( !_instance ) {
        _instance = new TapeDrive();
    }

    return _instance;
}

TapeDrive::TapeDrive()
        : _fd ( -1 ),
          _readOnly( true ),
          _tape( 0 ),
          _writeBuf( 0 ),
          _readBuf( 0 ),
          _writeBufIdx( 0 ),
          _readBufIdx( Options::instance()->getTapeBlockSize() )
{
    setBlockSize( Options::instance()->getTapeBlockSize() );
    _writeBuf = new char[ Options::instance()->getTapeBlockSize() ];
    _readBuf  = new char[ Options::instance()->getTapeBlockSize() ];
}

TapeDrive::~TapeDrive()
{
    if ( Options::instance()->getLockOnMount() ) {
        unlock();
    }

    delete [] _writeBuf;
    delete [] _readBuf;
}

void TapeDrive::flush()
{
    _readBufIdx = Options::instance()->getTapeBlockSize();

    if ( _writeBufIdx <= 0 ) {
        return;
    }

    memset( _writeBuf + _writeBufIdx, 0, Options::instance()->getTapeBlockSize() - _writeBufIdx );
    int ret = ::write( _fd, _writeBuf, Options::instance()->getTapeBlockSize() );
    if ( ret < 0 ) {
        printf( "TapeDrive::flush() -- write failed!\n" );
    }

    _writeBufIdx = 0;
}

bool TapeDrive::load()
{
    if ( _fd < 0 ) {
        return false;
    }

#ifdef MTLOAD
    struct mtop tapeOp;
    tapeOp.mt_op    = MTLOAD;
    tapeOp.mt_count = 1;

    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::lock() -- ioctl( MTLOAD ) failed!\n" );
    }

    return ret >= 0;
#else
    return true;
#endif
}

bool TapeDrive::lock()
{
    if ( _fd < 0 ) {
        return false;
    }

#ifdef MTLOCK
    struct mtop tapeOp;
    tapeOp.mt_op    = MTLOCK;
    tapeOp.mt_count = 1;

    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::lock() -- ioctl( MTLOCK ) failed!\n" );
    }

    return ret >= 0;
#else
    return true;
#endif
}

bool TapeDrive::unlock()
{
    if ( _fd < 0 ) {
        return false;
    }

#ifdef MTUNLOCK
    struct mtop tapeOp;
    tapeOp.mt_op    = MTUNLOCK;
    tapeOp.mt_count = 1;

    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::unlock() -- ioctl( MTUNLOCK ) failed!\n" );
    }

    return ret >= 0;
#else
    return true;
#endif
}

bool TapeDrive::isReadOnly()
{
    return _readOnly;
}

bool TapeDrive::isTapePresent()
{
    open();
    if ( _fd < 0 ) {
        return false;
    }

    // Get tape status.
    struct mtget tapeStatus;
    int ret = ioctl( _fd, MTIOCGET, &tapeStatus );
    if ( ret < 0 ) {
        return false;
    }

    // Check for the presence of a tape.
//    if ( !GMT_DR_OPEN( tapeStatus.mt_gstat ) ) {
    if ( GMT_ONLINE( tapeStatus.mt_gstat ) ) {
        // Lock the tape drive door.
        //struct mtop tapeOp;
        //tapeOp.mt_op    = MTLOCK;
        //tapeOp.mt_count = 1;
        //int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
        //if ( ret < 0 ) {
        //    printf( "TapeDrive::isTapePresent() -- ioctl( MTLOCK ) failed!\n" );
        //}

        if ( _readOnly ) {
            emit sigStatus( i18n( "Tape mounted readonly." ) );
        } else {
            emit sigStatus( i18n( "Tape mounted read/write." ) );
        }
        return true;
    } else {
        return false;
    }
}

void TapeDrive::eject()
{
    if ( _fd < 0 ) {
        return;
    }

    flush();
    
    struct mtop tapeOp;
    tapeOp.mt_op    = MTOFFL;
    tapeOp.mt_count = 1;
    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::ejectTape() -- ioctl( MTOFFL ) failed!\n" );
    }
}

Tape* TapeDrive::readHeader()
{
    _tape = NULL;
    
    // Rewind tape.
    emit sigStatus( "Rewinding tape..." );
    if ( !rewind() ) {
        KMessageBox::error( KDatMainWindow::getInstance(), i18n( "Rewinding tape failed." ));
        return NULL;
    }

    // KDat magic string.
    emit sigStatus( i18n( "Reading magic string..." ) );
    char magic[9];
    if ( read( magic, 9 ) < 9 ) {
        KMessageBox::error( KDatMainWindow::getInstance(), i18n( "Reading magic string failed." ));
        return NULL;
    }
    if ( strncmp( "KDatMAGIC", magic, 9 ) ) {
        // Bad magic.
        return NULL;
    }

    // Read version number.
    emit sigStatus( i18n( "Reading version number..." ) );
    int version;
    if ( read( (char*)&version, 4 ) < 4 ) {
        KMessageBox::error( KDatMainWindow::getInstance(), i18n( "Reading version number failed." ));
        return NULL;
    }

    if ( version > KDAT_TAPE_HEADER_VERSION ) {
        KMessageBox::information( KDatMainWindow::getInstance(), i18n( "Tape was formatted by a more recent version of KDat. Consider upgrading." ));
    }

    // Read tape ID.
    emit sigStatus( i18n( "Reading tape ID..." ) );
    int len;
    if ( read( (char*)&len, 4 ) < 4 ) {
        KMessageBox::error( KDatMainWindow::getInstance(), i18n( "Reading tape ID length failed." ));
        return NULL;
    }
    char* tapeID = new char[len];
    if ( read( tapeID, len ) < len ) {
        KMessageBox::error( KDatMainWindow::getInstance(), i18n( "Reading tape ID failed." ));
        delete [] tapeID;
        return NULL;
    }

    _tape = TapeManager::instance()->findTape( tapeID );
    delete [] tapeID;
    return _tape;
}

bool TapeDrive::rewind()
{
    if ( _fd < 0 ) {
        return false;
    }

    flush();

    struct mtop tapeOp;
    tapeOp.mt_op    = MTREW;
    tapeOp.mt_count = 1;
    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::rewind() -- ioctl( MTREW ) failed!\n" );
    }

    return ret >= 0;
}

int TapeDrive::getFile()
{
    if ( _fd < 0 ) {
        return -1;
    }

    struct mtget tapePos;
    
    if ( ioctl( _fd, MTIOCGET, &tapePos ) < 0 ) {
        printf( "TapeDrive::getFile() -- ioctl( MTIOCGET ) failed!\n" );
        return -1;
    }

    return tapePos.mt_fileno;
}

int TapeDrive::getBlock()
{
    if ( _fd < 0 ) {
        return -1;
    }

    struct mtget tapePos;
    
    if ( ioctl( _fd, MTIOCGET, &tapePos ) < 0 ) {
        printf( "TapeDrive::getBlock() -- ioctl( MTIOCGET ) failed!\n" );
        return -1;
    }

    //%%% I don't think this makes sense anymore because the tape buffer size == the tape block size.
    // Need to subtract off the blocks that the application has not "read" yet.
    //int unread = ( Options::instance()->getTapeBlockSize() - _readBufIdx ) / Options::instance()->getTapeBlockSize();

    //return tapePos.mt_blkno - unread;

    return tapePos.mt_blkno;
}

bool TapeDrive::nextFile( int count )
{
    if ( _fd < 0 ) {
        return false;
    }

    flush();
    
    struct mtop tapeOp;
    tapeOp.mt_op    = MTFSF;
    tapeOp.mt_count = count;
    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::nextFile() -- ioctl( MTFSF ) failed!\n" );
    }
    return ret >= 0;
}

bool TapeDrive::prevFile( int count )
{
    if ( _fd < 0 ) {
        return false;
    }

    flush();
    
    struct mtop tapeOp;
    tapeOp.mt_op    = MTBSF;
    tapeOp.mt_count = count;
    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::prevFile() -- ioctl( MTBSF ) failed!\n" );
    }
    return ret >= 0;
}

bool TapeDrive::nextRecord( int count )
{
    if ( _fd < 0 ) {
        return false;
    }

    flush();
    
    struct mtop tapeOp;
    tapeOp.mt_op    = MTFSR;
    tapeOp.mt_count = count;

    bool status = ( ioctl( _fd, MTIOCTOP, &tapeOp ) >= 0 );

    if ( !status ) {
        // Try reading count * TapeBlockSize bytes.
        char *buf = new char[Options::instance()->getTapeBlockSize()];
        int bytes = count * Options::instance()->getTapeBlockSize();
        int ret;
        while ( bytes > 0 ) {
            ret = read( buf, bytes > Options::instance()->getTapeBlockSize() ? Options::instance()->getTapeBlockSize() : bytes );
            if ( ret <= 0 ) {
                status = false;
                break;
            }
            bytes -= ret;
        }
        delete [] buf;
        status = true;
    }
    return status;
}

bool TapeDrive::prevRecord( int count )
{
    if ( _fd < 0 ) {
        return false;
    }

    flush();

    struct mtop tapeOp;
    tapeOp.mt_op    = MTBSR;
    tapeOp.mt_count = count;
    int ret = ioctl( _fd, MTIOCTOP, &tapeOp );
    if ( ret < 0 ) {
        printf( "TapeDrive::prevRecord() -- ioctl( MTBSR ) failed!\n" );
    }
    return ret >= 0;
}

void TapeDrive::close()
{
    if ( _fd < 0 ) {
        return;
    }

    flush();

    ::close( _fd );
}

void TapeDrive::open()
{
    close();

    // Open the tape device.
    _fd = ::open( TQFile::encodeName(Options::instance()->getTapeDevice()), O_RDWR );
    if ( _fd < 0 ) {
        _fd = ::open( TQFile::encodeName(Options::instance()->getTapeDevice()), O_RDONLY );
        if ( _fd < 0 ) {
            return;
        } else {
            _readOnly = true;
        }
    } else {
        _readOnly = false;
    }

    // Set the tape block size after the device is opened.
    setBlockSize( Options::instance()->getTapeBlockSize() );
}

int TapeDrive::read( char* buf, int len )
{
    if ( _fd < 0 ) {
        return -1;
    }

    //printf( "TapeDrive::read() -- _readBufIdx = %d\n", _readBufIdx );

    int remain = Options::instance()->getTapeBlockSize() - _readBufIdx;
    if ( len <= remain ) {
        memcpy( buf, _readBuf + _readBufIdx, len );
        _readBufIdx += len;
    } else {
        memcpy( buf, _readBuf + _readBufIdx, remain );
        _readBufIdx = Options::instance()->getTapeBlockSize();

        int need = Options::instance()->getTapeBlockSize();
        int count = 0;
        while ( need > 0 ) {
            int ret = ::read( _fd, _readBuf + count, Options::instance()->getTapeBlockSize() );
            if ( ret <= 0 ) return ret;
            need -= ret;
            count += ret;
        }

        memcpy( buf + remain, _readBuf, len - remain );
        _readBufIdx = len - remain;
    }

    //int ret = ::read( _fd, buf, len );
    return len;
}

int TapeDrive::write( const char* buf, int len )
{
    if ( _fd < 0 ) {
        return -1;
    }

    int bufIdx = 0;
    while ( len + _writeBufIdx - bufIdx > Options::instance()->getTapeBlockSize() ) {
        memcpy( _writeBuf + _writeBufIdx, buf + bufIdx, Options::instance()->getTapeBlockSize() - _writeBufIdx );
        int ret = ::write( _fd, _writeBuf, Options::instance()->getTapeBlockSize() );
        if ( ret < 0 ) {
            printf( "TapeDrive::write() -- write failed!\n" );
            return ret;
        }
        bufIdx += Options::instance()->getTapeBlockSize() - _writeBufIdx;
        _writeBufIdx = 0;
    }

    if ( bufIdx < len ) {
        memcpy( _writeBuf + _writeBufIdx, buf + bufIdx, len - bufIdx );
        _writeBufIdx += len - bufIdx;
    }

    return len;
}

bool TapeDrive::seek( int file, int tarBlock )
{
//    printf( "TapeDrive::seek() -- file = %d, block = %d\n", file, tarBlock );

    if ( _fd < 0 ) {
        printf( "bailing1\n" );
        return false;
    }

    flush();

    // Go to the desired archive.
    emit sigStatus( i18n( "Skipping to archive..." ) );

    int curFile = getFile();
//    printf( "TapeDrive::seek() -- curFile = %d\n", curFile );
    if ( curFile < 0 ) {
        emit sigStatus( i18n( "Rewinding tape..." ) );
        rewind();
        curFile = 0;
    }

    int fileDiff = file - curFile;
    if ( fileDiff > 0 ) {
        nextFile( fileDiff );
    } else if ( fileDiff < 0 ) {
        prevFile( -fileDiff + 1 );
        nextFile( 1 );
    }

    int tapeBlock = tarBlock / ( Options::instance()->getTapeBlockSize() / 512 );
//    printf( "TapeDrive::seek() -- desired tapeBlock = %d\n", tapeBlock );

    // Go to the desired record within the archive.
    emit sigStatus( i18n( "Skipping to block..." ) );
    int curBlock = getBlock();
//    printf( "TapeDrive::seek() -- curBlock = %d\n", curBlock );
    if ( curBlock < 0 ) {
        emit sigStatus( i18n( "Rewinding tape..." ) );
        rewind();
        nextFile( file );
        if ( ( curBlock = getBlock() ) < 0 ) {
            printf( "bailing2\n" );
            return false;
        }
    }

    if ( tapeBlock > curBlock ) {
        if ( !nextRecord( tapeBlock - curBlock ) ) {
            printf( "bailing3\n" );
            return false;
        }
    } else if ( tapeBlock < curBlock ) {
        if ( tapeBlock == 0 ) {
            if ( !prevFile( 1 ) ) {
                printf( "bailing6\n" );
                return false;
            }
            if ( !nextFile( 1 ) ) {
                printf( "bailing7\n" );
                return false;
            }
        } else {
            if ( !prevRecord( curBlock - tapeBlock + 1 ) ) {
                printf( "bailing4\n" );
                return false;
            }
            if ( !nextRecord( 1 ) ) {
                printf( "bailing5\n" );
                return false;
            }
        }
    }

//    printf( "TapeDrive::seek() -- now: file = %d, block = %d\n", getFile(), getBlock() );

    // If tapeBlockSize > 512, we may need to skip some tar blocks.
//    printf ( "TapeDrive::seek() -- skipping %d tar blocks.\n", tarBlock - tapeBlock * ( Options::instance()->getTapeBlockSize() / 512 ) );
    char *buf = new char[ Options::instance()->getTapeBlockSize() ];
    read( buf, 512 * ( tarBlock - tapeBlock * ( Options::instance()->getTapeBlockSize() / 512 ) ) );

    delete [] buf;
    
    return true;
}

bool TapeDrive::pastEOF()
{
    if ( _fd < 0 ) {
        return false;
    }

    struct mtget tapeStatus;
    if ( ioctl( _fd, MTIOCGET, &tapeStatus ) < 0 ) {
        printf( "TapeDrive::pastEOF() -- ioctl( MTIOCGET ) failed!\n" );
        return false;
    }

    return GMT_EOF( tapeStatus.mt_gstat );
}

bool TapeDrive::setBlockSize( int blockSize )
{
    if ( _fd < 0 ) {
        return false;
    }

#ifdef MTSETBLK
    flush();

    int ret = 0;
    if ( Options::instance()->getVariableBlockSize() ) {
        struct mtop tapeOp;
        tapeOp.mt_op    = MTSETBLK;
        tapeOp.mt_count = blockSize;
        ret = ioctl( _fd, MTIOCTOP, &tapeOp );
        if ( ret < 0 ) {
            printf( "TapeDrive::setBlockSize() -- ioctl( MTSETBLK ) failed!\n" );
        }
    }

    _readBufIdx = blockSize;
    _writeBufIdx = 0;
    delete [] _readBuf;
    _readBuf = new char[ blockSize ];
    delete [] _writeBuf;
    _writeBuf = new char[ blockSize ];

    return ret >= 0;
#else
    // some systems encode block size into device file names
    // so setting the block size by software does not make sense
    return true;
#endif
}
