/* based on gpSP which took it from gameplaySP
 *
 * Copyright (C) 2017 critor
 * Copyright (C) 2012 calc84maniac
 * Copyright (C) 2006 Exophase <exophase@gmail.com>
 * Copyright (C) 2006 SiberianSTAR
 *
 * 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 "zlib.h"
#include "common.h"

#define ZIP_BUFFER_SIZE (128 * 1024)

u32 path_size;

struct SZIPFileDataDescriptor
{
  s32 CRC32;
  s32 CompressedSize;
  s32 UncompressedSize;
} __attribute__((packed));

struct SZIPFileHeader
{
  s32 Sig;
  s16 VersionToExtract;
  s16 GeneralBitFlag;
  s16 CompressionMethod;
  s16 LastModFileTime;
  s16 LastModFileDate;
  struct SZIPFileDataDescriptor DataDescriptor;
  s16 FilenameLength;
  s16 ExtraFieldLength;
}  __attribute__((packed));

int mkdirs(const char *dir, const mode_t mode) { /* recursive mkdir */
    char tmp[PATH_SIZE];
    char *p = NULL;
    struct stat sb;
    size_t len = strlen(dir);
    if (len <PATH_SIZE) {
		strncpy(tmp, dir, len);
		p=strrchr(tmp,'/');
		if(p) {
			*p=0;
			for(p = tmp + 1; *p; p++) {
				if(*p == '/') {
					*p = 0;
					if (stat(tmp, &sb)) { /* path does not exist - create directory */
						printf("Creating directory %s\n",tmp+path_size);
						if(mkdir(tmp, mode) < 0) return -1;
					} else if(!(sb.st_mode & S_IFDIR)) return -1; /* not a directory */					
					*p = '/';
				}
			}
		}
		if (stat(tmp, &sb)) { /* path does not exist - create directory */			
			printf("Creating directory %s\n",tmp+path_size);
			return mkdir(tmp, mode);
		}
		else return (sb.st_mode & S_IFDIR)?0:-1;
	}
    return -1;
}

u32 getZipFileDataOffset(char* zipname, u32 startoffset, char* filename) {
	u32 zipoffset=0;
	struct SZIPFileHeader data;
	u8 tmp[PATH_SIZE];
	FILE *hi = fopen(zipname, "rb");
	if(hi) {
		fseek(hi,startoffset,SEEK_SET);
		while(!zipoffset && fread(&data, 1, sizeof(struct SZIPFileHeader), hi) && data.Sig == 0x04034b50 && fread(tmp, 1, data.FilenameLength, hi)) {
			tmp[data.FilenameLength] = 0; // end string
			if(data.ExtraFieldLength) fseek(hi, data.ExtraFieldLength, SEEK_CUR);
			if(data.GeneralBitFlag & 0x0008)
				fread(&data.DataDescriptor, 1, sizeof(struct SZIPFileDataDescriptor), hi);
			if(data.DataDescriptor.CompressedSize) {
				if(!strcmp(tmp,filename))
					zipoffset=ftell(hi);
				fseek(hi, data.DataDescriptor.CompressedSize, SEEK_CUR);
			}
		}
	}
	if(hi) fclose(hi);
	return zipoffset;
}

// set nsext to add an Nspire extension to extracted files, forcing them to be visible in the Nspire browser
u32 extract_zip(char *filename, char* path, u8 nsext, u32 startoffset) {
	struct SZIPFileHeader data;
	u8 tmp[PATH_SIZE];
	path_size=strlen(path);
	strncpy(tmp,path,path_size);
	u32 buffer_size=1;
	u8 *buffer = malloc(buffer_size);
	if(!buffer) buffer_size=0;
	u32 cbuffer_size=1;
	u8 *cbuffer = malloc(cbuffer_size);
	if(!cbuffer) cbuffer_size=0;
	char* ext;
	FILE *hi = fopen(filename, "rb");
	if(hi && buffer && cbuffer) {
		u8* tptr;
		FILE *ho;
		u32 read_size=0;
		u32 write_size=0;
		u32 size;
		z_stream stream;
		s32 err;
		fseek(hi,startoffset,SEEK_SET);
		while(fread(&data, 1, sizeof(struct SZIPFileHeader), hi) && data.Sig == 0x04034b50 && fread(tmp+path_size, 1, data.FilenameLength, hi)) {
			tmp[path_size+data.FilenameLength] = 0; // end string
			if(data.ExtraFieldLength) fseek(hi, data.ExtraFieldLength, SEEK_CUR);
			if(data.GeneralBitFlag & 0x0008) {
				fread(&data.DataDescriptor, 1, sizeof(struct SZIPFileDataDescriptor), hi);
			}
			mkdirs(tmp,S_IRUSR | S_IWUSR | S_IXUSR);
			if(data.DataDescriptor.CompressedSize) {
				if(data.DataDescriptor.UncompressedSize > buffer_size) {
					tptr=buffer;
					buffer = realloc(buffer,data.DataDescriptor.UncompressedSize);
					if(buffer) buffer_size=data.DataDescriptor.UncompressedSize;
					else buffer=tptr;
				}
				read_size=0;
				write_size=0;
				if(nsext) {
					ext = strrchr(tmp,'.');
					if(!ext || (ext && strcmp(ext,".tns")))
						strcat(tmp,".tns");
				}
				ho = fopen(tmp, "wb");
				if(!ho) fseek(hi, data.DataDescriptor.CompressedSize, SEEK_CUR);
				else {
					switch(data.CompressionMethod) {
						case 0:
							printf("Extracting file %s\n",tmp);
							while(read_size<data.DataDescriptor.UncompressedSize) {
								size = MIN(data.DataDescriptor.UncompressedSize-read_size,buffer_size);
								read_size+=fread(buffer, 1, size, hi);
								fwrite(buffer, 1, size, ho);
							}
							break;
						case 8:
							printf("Inflating file %s\n",tmp);
							if(data.DataDescriptor.CompressedSize > cbuffer_size) {
								tptr = cbuffer;
								cbuffer = realloc(cbuffer,data.DataDescriptor.CompressedSize);
								if(cbuffer) cbuffer_size=data.DataDescriptor.CompressedSize;
								else cbuffer=tptr;
							}
							stream.next_in = (Bytef*)cbuffer;
							stream.avail_in = cbuffer_size;
							stream.next_out = (Bytef*)buffer;
							stream.avail_out = buffer_size;
							stream.zalloc = (alloc_func)0;
							stream.zfree = (free_func)0;
							err = inflateInit2(&stream, -MAX_WBITS);
							read_size+=fread(cbuffer, 1, MIN(data.DataDescriptor.CompressedSize,cbuffer_size), hi);
							if(err == Z_OK) {
								while(err != Z_STREAM_END) {
									err = inflate(&stream, Z_SYNC_FLUSH);
									if(err == Z_BUF_ERROR) {
										if(!stream.avail_in) {
											stream.avail_in = cbuffer_size;
											stream.next_in = (Bytef*)cbuffer;
											read_size+=fread(cbuffer, 1, MIN(data.DataDescriptor.CompressedSize-read_size,cbuffer_size), hi);
										}
										else if(!stream.avail_out) {
											stream.avail_out = buffer_size;
											stream.next_out = (Bytef*)buffer;
											write_size+=fwrite(buffer, 1, MIN(data.DataDescriptor.UncompressedSize-write_size,buffer_size), hi);
										}
										else break;
									}
								}
								err = Z_OK;
								inflateEnd(&stream);
								fwrite(buffer, 1, MIN(data.DataDescriptor.UncompressedSize-write_size,buffer_size), ho);
							}
					}	
					fclose(ho);
				}
			}
		}
	}
	if(hi) fclose(hi);
	if(buffer) free(buffer);
	if(cbuffer) free(cbuffer);
	return hi && buffer;
}