// File_Extractor 1.0.0. http://www.slack.net/~ant/

#include "Zip7_Extractor.h"

extern "C" {
#include "7z_C/7z.h"
#include "7z_C/7zAlloc.h"
#include "7z_C/7zCrc.h"
}

#include <time.h>

/* Copyright (C) 2005-2009 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this module; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

#include "blargg_source.h"

static ISzAlloc zip7_alloc      = { SzAlloc,     SzFree     };
static ISzAlloc zip7_alloc_temp = { SzAllocTemp, SzFreeTemp };

struct Zip7_Extractor_Impl :
	ISeekInStream
{
	CLookToRead2 look;
	CSzArEx db;
	
	// SzExtract state
	UInt32  block_index;
	Byte*   buf;
	size_t  buf_size;

	File_Reader* in;
	const char* in_err;
};

extern "C"
{
	// 7-zip callbacks pass an ISeekInStream* for data, so we must cast it
	// back to ISeekInStream* FIRST, then cast to our Impl structure
	
	static SRes zip7_read_( ISeekInStreamPtr vstream, void* out, size_t* size )
	{
		assert( out && size );
        ISeekInStream *stream = (ISeekInStream *)vstream;
		Zip7_Extractor_Impl* impl = (Zip7_Extractor_Impl*)stream;
		
		long lsize = (long)*size;
		blargg_err_t err = impl->in->read_avail( out, &lsize );
		if ( err )
		{
			*size = 0;
			impl->in_err = err;
			return SZ_ERROR_READ;
		}
		
		*size = lsize;
		return SZ_OK;
	}

	static SRes zip7_seek_( ISeekInStreamPtr vstream, Int64* pos, ESzSeek mode )
	{
		ISeekInStream *stream = (ISeekInStream *)vstream;
		Zip7_Extractor_Impl* impl = (Zip7_Extractor_Impl*)stream;
		
		// assert( mode != SZ_SEEK_CUR ); // never used
		
		if ( mode == SZ_SEEK_END )
		{
			assert( *pos == 0 ); // only used to find file length
			*pos = impl->in->size();
			return SZ_OK;
		}
		
		// assert( mode == SZ_SEEK_SET );
		blargg_err_t err = impl->in->seek( (int)*pos );
		if ( err )
		{
			// don't set in_err in this case, since it might be benign
			if ( err == blargg_err_file_eof )
				return SZ_ERROR_INPUT_EOF;
			
			impl->in_err = err;
			return SZ_ERROR_READ;
		}
		
		return SZ_OK;
	}
}

blargg_err_t Zip7_Extractor::zip7_err( int err )
{
	// TODO: ignore in_err in some cases? unsure about which error to use
	blargg_err_t in_err = impl->in_err;
	impl->in_err = NULL;
	if ( in_err )
	{
		check( err != SZ_OK );
		return in_err;
	}
	
	switch ( err )
	{
	case SZ_OK:                 return blargg_ok;
	case SZ_ERROR_MEM:          return blargg_err_memory;
	case SZ_ERROR_READ:         return blargg_err_file_io;
	case SZ_ERROR_CRC:
	case SZ_ERROR_DATA:
	case SZ_ERROR_INPUT_EOF:
	case SZ_ERROR_ARCHIVE:      return blargg_err_file_corrupt;
	case SZ_ERROR_UNSUPPORTED:  return blargg_err_file_feature;
	case SZ_ERROR_NO_ARCHIVE:   return blargg_err_file_type;
	}
	
	return blargg_err_generic;
}

static blargg_err_t init_7z()
{
	static bool inited;
	if ( !inited )
	{
		inited = true;
		CrcGenerateTable();
	}
	return blargg_ok;
}

static File_Extractor* new_7z()
{
	return BLARGG_NEW Zip7_Extractor;
}

fex_type_t_ const fex_7z_type [1] = {{
	".7z",
	&new_7z,
	"7-zip archive",
	&init_7z
}};

Zip7_Extractor::Zip7_Extractor() :
	File_Extractor( fex_7z_type )
{
	impl = NULL;
}

Zip7_Extractor::~Zip7_Extractor()
{
	close();
}

#ifndef kInputBufSize
#define kInputBufSize ((size_t)1 << 18)
#endif /* kInputBufSize */

blargg_err_t Zip7_Extractor::open_v()
{
	RETURN_ERR( init_7z() );
	
	if ( !impl )
	{
		impl = (Zip7_Extractor_Impl*) malloc( sizeof *impl );
		CHECK_ALLOC( impl );
	}
	
	impl->in          = &arc();
	impl->block_index = (UInt32) -1;
	impl->buf         = NULL;
	impl->buf_size    = 0;

	LookToRead2_CreateVTable( &impl->look, false );
	impl->ISeekInStream::Read = zip7_read_;
	impl->ISeekInStream::Seek = zip7_seek_;
    impl->look.buf            = (Byte *)ISzAlloc_Alloc(&zip7_alloc, kInputBufSize);
    impl->look.bufSize        = kInputBufSize;
	impl->look.realStream     = impl;
	LookToRead2_INIT( &impl->look );
	
	SzArEx_Init( &impl->db );
	
	impl->in_err = NULL;
	RETURN_ERR( zip7_err( SzArEx_Open( &impl->db, &impl->look.vt,
			&zip7_alloc, &zip7_alloc_temp ) ) );
	
	return seek_arc_v( 0 );
}

void Zip7_Extractor::close_v()
{
	if ( impl )
	{
		if ( impl->in )
		{
			impl->in = NULL;
			SzArEx_Free( &impl->db, &zip7_alloc );
		}
		IAlloc_Free( &zip7_alloc, impl->buf );
		free( impl );
		impl = NULL;
	}
}

// This method was taken from ogre-7z (thanks), and is thus LGPL
bool Zip7_Extractor::utf16ToUtf8( unsigned char* dest, size_t* destLen, const short* src, size_t srcLen )
{
	static const unsigned char sUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

	size_t destPos = 0, srcPos = 0;
	for(;;)
	{
		unsigned int numAdds;
		unsigned long value;
		if( srcPos == srcLen )
		{
			*destLen = destPos;
			return true;
		}

		value = src[srcPos++];
		if( value < 0x80 )
		{
			if( dest )
			{
				dest[destPos] = (char)value;
			}
			destPos++;
			continue;
		}

		if( value >= 0xD800 && value < 0xE000 )
		{
			unsigned long c2;
			if( value >= 0xDC00 || srcPos == srcLen )
				break;

			c2 = src[srcPos++];
			if( c2 < 0xDC00 || c2 >= 0xE000 )
				break;

			value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
		}

		for( numAdds = 1; numAdds < 5; numAdds++ )
		{
			if( value < (((UInt32)1) << (numAdds * 5 + 6)) )
				break;
		}

		if( dest )
		{
			dest[destPos] = (char)(sUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
		}

		destPos++;
		do
		{
			numAdds--;
			if( dest )
			{
				dest[destPos] = (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
			}
			destPos++;
		}
		while( numAdds != 0 );
	}

	*destLen = destPos;
	return false;
}

blargg_err_t Zip7_Extractor::next_v()
{
	while ( ++index < (int) impl->db.NumFiles )
	{
		if ( !SzArEx_IsDir(&impl->db, index) )
		{
			if ( SzBitWithVals_Check(&impl->db.MTime, index) )
			{
				const UInt64 epoch = ((UInt64)0x019db1de << 32) + 0xd53e8000;
				/* 0x019db1ded53e8000ULL: 1970-01-01 00:00:00 (UTC) */
				struct tm tm;

				UInt64 time = ((((UInt64)impl->db.MTime.Vals[index].High) << 32) | impl->db.MTime.Vals[index].Low)  - epoch;
				time /= 1000000;

				time_t _time = time;
				
			#ifdef _WIN32
				#if __STDC_WANT_SECURE_LIB__
					localtime_s(&tm, &_time);
				#else
					tm = *localtime( &_time );
				#endif
			#else
				localtime_r( &_time, &tm );
			#endif

			}

			size_t name_length = SzArEx_GetFileNameUtf16( &impl->db, index, 0 );
			size_t utf8_length = 0;
			name16.resize( name_length );
			SzArEx_GetFileNameUtf16( &impl->db, index, ( UInt16 * ) name16.begin() );
			unsigned char temp[1024];
			utf16ToUtf8( temp, &utf8_length, (const short*)name16.begin(), name_length - 1 );
			temp[utf8_length] = '\0';

			name8.resize( utf8_length + 1 );
			memcpy( name8.begin(), temp, utf8_length + 1 );
			set_name( name8.begin(), name16.begin() );
			set_info( (int)SzArEx_GetFileSize(&impl->db, index), 0, (SzBitWithVals_Check(&impl->db.CRCs, index) ? impl->db.CRCs.Vals[index] : 0) );
			break;
		}
	}
	
	return blargg_ok;
}

blargg_err_t Zip7_Extractor::rewind_v()
{
	return seek_arc_v( 0 );
}

fex_pos_t Zip7_Extractor::tell_arc_v() const
{
	return index;
}

blargg_err_t Zip7_Extractor::seek_arc_v( fex_pos_t pos )
{
	assert( 0 <= pos && pos <= (int) impl->db.NumFiles );
	
	index = pos - 1;
	return next_v();
}

blargg_err_t Zip7_Extractor::data_v( void const** out )
{
	impl->in_err = NULL;
	size_t offset = 0;
	size_t count  = 0;
	RETURN_ERR( zip7_err( SzArEx_Extract( &impl->db, &impl->look.vt, index,
			&impl->block_index, &impl->buf, &impl->buf_size,
			&offset, &count, &zip7_alloc, &zip7_alloc_temp ) ) );
	assert( count == (size_t) size() );
	
	*out = impl->buf + offset;
	return blargg_ok;
}
