/* 
 * Copyright (C) 2003	Wesley Oliveira, Aline Oliveira, Hudson Reis, 
 *               		Husni Ali Husni.
 * 
 * This library 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,
 * or (at your option) any later version.
 * 
 * This library 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 library; see the file COPYING.LIB.  If
 * not, write to the Free Software Foundation, Inc., 59 Temple Place,
 * Suite 330, Boston, MA 02111-1307 USA
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include "globals.h"

#ifndef MAXLINE
    #define MAXLINE 1024
    #define MINLINE  256
#endif

#if defined(SunOS)
#include <curses.h>
#else
#  if defined(__CYGWIN__)
#  include <ncurses/ncurses.h>
#  else
#    if defined(__MINGW32__)
#    include <curses.h> //#    include <pdcurses.h>
#    else
#    include <curses.h>
#    endif
#  endif
#endif

char cobpri[MAXLINE], cobpro[MAXLINE];

struct cbl_stream {
    char path[MAXLINE];
    FILE *fd;
    int  handle;
} cbl_stream[MAXLINE];

/* Prototypes */        

cbl_t cbl_copy_file(char *entrada, char *saida);        
cbl_t cbl_rename_file(char *old, char *new);                
cbl_t cbl_delete_file(char *arquivo);                
cbl_t cbl_check_file_exist(char *arquivo);
cbl_t cbl_move_file(char *origem,char *destino);        
void cbl_open_file(char *arquivo,char *access_mode,
           char *deny_mode, int file_handle,
           cbl_t *retorno);
void cbl_create_file(char *arquivo, unsigned char *access_mode,
           unsigned char *deny_mode, char file_handle[5],
           cbl_t *retorno);
cbl_t cbl_close_file(int file_handle);
cbl_t cbl_flush_file(int file_handle);
void cbl_read_file(int file_handle, int number_bytes,
            char *buffer_read, cbl_t *retorno);
void cbl_write_file(int file_handle,int number_bytes,char *buffer_writed,cbl_t *retorno);

/* Functions */

cbl_t cbl_copy_file(char *entrada, char *saida) {
    FILE *fd_in, *fd_out;
	int c,valor;
        
	if ( cbl_align(entrada) != 0 ) { 
		return 1; 
	}
    
    if( cbl_align(saida) != 0 ) { 
		return 1; 
	}

    if ( (valor=cbl_parm(entrada,saida)) == -2 ) { 
		return 0; 
	}
	
    if ( valor == 1 ) { 
		return 1; 
	}

    if ( (fd_in = fopen(cobpri,"rb")) == NULL ) { 
		return 3; 
	} 
    else {
		if ( (fd_out=fopen(cobpro,"wb")) == NULL ) {
			fclose(fd_in);
            return 3;
        }
	}
        
	while ( (c = fgetc(fd_in)) != EOF ) {
		fputc(c,fd_out);
	}

#ifdef __MSVCRT__
	chmod(cobpro,0666);
#else
	cbl_get_per(cobpro);
#endif
        
	fclose(fd_in);
    fclose(fd_out);

    return 0;
}

cbl_t cbl_rename_file(char *old, char *new) {
	int valor;

	if ( cbl_align(old) != 0 ) { 
		return 1; 
	}
    
    if (cbl_align(new) != 0) { 
		return 1; 
	}

    valor = cbl_parm(old,new);

    if(valor == 1) { 
		return valor; 
	}
    
	if (rename(cobpri,cobpro) == 0) { 
		return 0; 
	} 
    else {    
		return 3; 
	}
}

cbl_t cbl_delete_file(char *arquivo) {
    int valor;

    if ( cbl_align(arquivo) != 0 ) { 
		return 1; 
	}

    if ( (valor=cbl_parm(arquivo,""))== -2 ) { 
		return 0; 
	}
    
	if ( valor == 1 ) { 
		return valor; 
	}
    
    chdir(cobpri);
    
    if (remove(cobpri) != 0) { 
		return 2; 
	}

    return 0;
}

cbl_t cbl_check_file_exist(char *arquivo) {
    int valor;
	//DIR *dir;
    
    if (cbl_align(arquivo) != 0) { 
		return 1; 
	}

    valor = cbl_parm(arquivo,"");
    
    if ( opendir(cobpri) != NULL ) { 
		return(-1); 
	}
    
    if ( access(cobpri,F_OK) != 0 ) { 
		return 1; 
	}
    
	return 0;
}

cbl_t cbl_move_file(char *origem, char *destino) {
    int valor;
        
	if ( cbl_align(origem)  != 0 ) { 
		return 1; 
	}
    
	if ( cbl_align(destino) != 0 ) { 
		return 1; 
	}
        
    valor = cbl_parm(origem,destino);
    
	if ( valor == 1 ) { 
		return valor; 
	}

	if (cbl_copy_file(cobpri,cobpro) == 0) {	
		if (cbl_delete_file(cobpri) != 0) { 
			return 5; 
		}
	} 
    else { 
		return 3; 
	}

    return 0;
}

void cbl_open_file(char *arquivo, char *access_mode,
           char *deny_mode,int file_handle,
           cbl_t *retorno) {
    register int i;
    int valor;

    cbl_align(arquivo);
    cbl_align(access_mode);
    cbl_align(deny_mode);
    valor=cbl_parm(arquivo,"");
//    if(valor == 1) { return valor; } walter
	if ( valor == 1 ) {
		*retorno = 1;
		return;
	}
    
    if ( !strcmp(access_mode,deny_mode) ) { 
        *retorno = 1; 
        return; 
    }
	
    for ( i=1 ; i<MAXLINE ; i++ ) {
        if ( !cbl_stream[i].fd ) {
            cbl_stream[i].handle=i;
            if ( (cbl_stream[i].fd = fopen(cobpri,access_mode) ) == NULL ) {
                *retorno = 1;
            }
            strcpy(cbl_stream[i].path,cobpri);
            *retorno=0;
            file_handle=cbl_stream[i].handle;
            break;
        }
    }                        
}


void cbl_read_file(int file_handle,int number_bytes,char *buffer_read, cbl_t *retorno) {
    *retorno = 0;

    if ( fread(buffer_read,sizeof(char),number_bytes,cbl_stream[file_handle].fd) == 0 ) {
        *retorno = 1;
    }
}
    
void cbl_write_file(int file_handle, int number_bytes,char *buffer_writed, cbl_t *retorno) {
    *retorno = 0;

    if( fwrite(buffer_writed,sizeof(char),number_bytes,cbl_stream[file_handle].fd) != number_bytes ) {
        *retorno = 1;
    }
}

cbl_t cbl_close_file(int file_handle) {
    register int i;
    
    fclose(cbl_stream[file_handle].fd);
    
	for ( i=0 ; i<MAXLINE ; i++ ) {
        cbl_stream[file_handle].path[i]=' ';
    }
	
    return 0;
}

cbl_t cbl_flush_file(int file_handle) {
    fflush(cbl_stream[file_handle].fd);
    
	return 0;
}


// show file
void show(char *arquivo) {
	FILE *file;
	char line[1025];
	unsigned int max_col, max_lines, p, fline, fcol, ncol, pnt;
	char *text, *c, *narq;
	int show, ca;

// copy the filename
	narq = malloc(sizeof(char) * 256); *narq = 0;
	c = arquivo;
	p = 0;
	
	while ( *(c+p) != ' ') {
		*(narq+p) = *(c+p);
		p++;
	}
	
	*(narq+p) = 0;

	// How many lines and the gratest line ?
	file = fopen(narq, "r");
	
	if ( !file )
		return;
	
	max_col = 0;
	max_lines = 0;
	fgets(line, 1024, file);
	while ( !feof(file) ) {
		if(strlen(line) > max_col)
			max_col = strlen(line);
		max_lines++;
		fgets(line, 1024, file);
	}
	fclose(file);
	
	file = fopen(narq, "r");

	// Alloc memory to put text
	text = malloc( (sizeof(char) * ( max_col * max_lines )) + 128 ); 
	*text = 0;
	memset(text, ' ', (sizeof(char) * ( max_col * max_lines )) + 128);
	fgets(line, 1024, file);
	
	p = 0;
	while ( !feof(file) ) {
		memcpy(text + p, line, strlen(line));
		p += max_col;
		fgets(line, 1024, file);
	}
	
	fclose(file);

	// show the file
	fline = 0; 
	fcol = 0; 
	ncol = 80;
	
	if(ncol > max_col)
		ncol = max_col;
	
	show = 1;
	while(show) {
		p = 0;
		while( (fline + p) < max_lines && p < 24) {
			move(p, 0);
			pnt = ( (fline + p) * max_col ) + fcol;
			addnstr(text + pnt, ncol);
			p++;
		}
		
		move(0, 0); 
		ca = getch();
		
		switch(ca) {
			case 'i':
			case 'I':	
				fline = 0;
				fcol = 0;
				break;
				
			case 'a':
			case 'A':	
				if ( fline > 0 )
					fline--;
				break;
				
			case 'z':
			case 'Z':	
				if ( fline < (max_lines - 24) )
					fline++;
				break;
				
			case ',':	
				if ( fcol > 0 )
					fcol--;
				break;
			
			case '.':	
				if ( fcol < (max_col - 80) )
					fcol++;
				break;

			case 'f':
			case 'F':	
				show = 0;
				break;
		}
	}

	// Return to the application
	free(text);
	free(narq);
	
	return;
}