/**

 * $Id$

 *

 * libisofs adapter

 *

 * Copyright (c) 2010 Nathan Keynes.

 *

 * 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.

 */

#include <assert.h>

#include <glib/gmem.h>

#define LIBISOFS_WITHOUT_LIBBURN 1

#include "drivers/cdrom/cdrom.h"

#include "drivers/cdrom/isofs.h"

static int isofs_dummy_fn(IsoDataSource *src)

{

    return 1;

}

static int isofs_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)

{

    sector_source_t source = (sector_source_t)src->data;

    cdrom_error_t err = sector_source_read_sectors(source, lba, 1,

            CDROM_READ_MODE2_FORM1|CDROM_READ_DATA, buffer, NULL );

    if( err != CDROM_ERROR_OK ) {

        return ISO_DATA_SOURCE_FAILURE;

    }

    return 1;

}

static void isofs_release(IsoDataSource *src)

{

    sector_source_unref((sector_source_t)src->data);

}

static IsoDataSource *iso_data_source_new( sector_source_t source )

{

    IsoDataSource *src = g_malloc0(sizeof(IsoDataSource));

    src->refcount = 1;

    src->open = isofs_dummy_fn;

    src->close = isofs_dummy_fn;

    src->read_block = isofs_read_block;

    src->free_data = isofs_release;

    src->data = source;

    sector_source_ref(source);

    return src;

}

/**

 * Construct an isofs image from an existing sector source.

 */

IsoImage *iso_image_new_from_source( sector_source_t source, cdrom_lba_t start, ERROR *err )

{

    IsoImage *iso = NULL;

    IsoReadOpts *opts;

    IsoDataSource *src;

    int status = iso_image_new(NULL, &iso);

    if( status != 1 )

        return NULL;

    status = iso_read_opts_new(&opts,0);

    if( status != 1 ) {

        iso_image_unref( iso );

        return NULL;

    }

    iso_read_opts_set_start_block(opts, start);

    src = iso_data_source_new(source);

    status = iso_image_import(iso, src, opts, NULL);

    iso_data_source_unref(src);

    iso_read_opts_free(opts);

    if( status != 1 ) {

        iso_image_unref(iso);

        return NULL;

    }

    return iso;

}

IsoImage *iso_image_new_from_disc( cdrom_disc_t disc, cdrom_lba_t start_sector, ERROR *err )

{

    return iso_image_new_from_source( &disc->source, start_sector, err );

}

IsoImage *iso_image_new_from_track( cdrom_disc_t disc, cdrom_track_t track, ERROR *err )

{

    return iso_image_new_from_source( &disc->source, track->lba, err );

}

IsoImageFilesystem *iso_filesystem_new_from_source( sector_source_t source, cdrom_lba_t start, ERROR *err )

{

    IsoImageFilesystem *iso = NULL;

    IsoReadOpts *opts;

    IsoDataSource *src;

    int status = iso_read_opts_new(&opts,0);

    if( status != 1 ) {

        return NULL;

    }

    iso_read_opts_set_start_block(opts, start);

    src = iso_data_source_new(source);

    status = iso_image_filesystem_new(src, opts, 0x1FFFFF, &iso);

    iso_data_source_unref(src);

    iso_read_opts_free(opts);

    if( status != 1 ) {

        return NULL;

    }

    return iso;

}

IsoImageFilesystem *iso_filesystem_new_from_disc( cdrom_disc_t disc, cdrom_lba_t start_sector, ERROR *err )

{

    return iso_filesystem_new_from_source( &disc->source, start_sector, err );

}

IsoImageFilesystem *iso_filesystem_new_from_track( cdrom_disc_t disc, cdrom_track_t track, ERROR *err )

{

    return iso_filesystem_new_from_source( &disc->source, track->lba, err );

}

/**

 * Construct a sector source from a given IsoImage.

 */

sector_source_t iso_sector_source_new( IsoImage *image, sector_mode_t mode, cdrom_lba_t start_sector,

                                       const char *bootstrap, ERROR *err )

{

    assert( mode == SECTOR_MODE1 || mode == SECTOR_MODE2_FORM1 );

    IsoWriteOpts *opts;

    struct burn_source *burn;

    int status = iso_write_opts_new(&opts, 0);

    if( status != 1 )

        return NULL;

    iso_write_opts_set_appendable(opts,0);

    iso_write_opts_set_ms_block(opts, start_sector);

    iso_write_opts_set_system_area(opts, (char *)bootstrap, 0, 0);

    status = iso_image_create_burn_source(image, opts, &burn);

    iso_write_opts_free(opts);

    if( status != 1 ) {

        return NULL;

    }

    off_t size = burn->get_size(burn);

    sector_source_t source = tmpfile_sector_source_new(mode);

    if( source == NULL ) {

        burn->free_data(burn);

        free(burn);

        return NULL;

    }

    char buf[2048];

    cdrom_count_t expect = size/2048;

    cdrom_count_t count = 0;

    for( cdrom_count_t count = 0; count < expect; count++ ) {

        status = burn->read(burn, buf, 2048);

        if( status == 0 ) {

            /* EOF */

            break;

        } else if( status != 2048 ) {

            /* Error */

            sector_source_unref(source);

            source = NULL;

            break;

        }

    }

    burn->free_data(burn);

    free(burn);

    return source;

}