/*
 * Copyright 2000-2004 by Hans Reiser, licensing governed by 
 * reiserfsprogs/README
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "debugreiserfs.h"
#include "misc/unaligned.h"

#include <errno.h>

#if 0

/* this reads stdin and recover file of given key:  */
/* the input has to be in the follwong format:
   K dirid objectid
   N name
   B blocknumber
   ..
   then recover_file will read every block, look there specified file and put it into
*/
void do_recover (reiserfs_filsys_t fs)
{
    char name [100];
    char * line = 0;
    int n = 0;
    int fd;
    reiserfs_key_t key = {0, 0, };
    reiserfs_bh_t * bh;
    reiserfs_ih_t * ih;
    unsigned long block;
    char code;
    long long int recovered = 0;
    int i, j;
    reiserfs_bitmap_t bitmap;
    int used, not_used;

    bitmap = reiserfs_bitmap_create (SB_BLOCK_COUNT (fs));
    reiserfs_fetch_disk_bitmap (bitmap, fs);
    /* we check how many blocks recoverd items point to are free or used */
    used = 0;
    not_used = 0;

    fd = 0;
    while (getline (&line, &n, stdin) != -1) {
	if (line [0] == '#' || line [0] == '\n')
	    continue;
	switch (line [0]) {
	case 'K':
	    /* get a key of file which is to be recovered */
	    if (sscanf (line, "%c %u %u\n", &code, &key.k_dir_id, &key.k_objectid) != 3) {
		misc_die ("recover_file: wrong input K format");
	    }
	    printf ("Recovering file (%u, %u)\n", key.k_dir_id, key.k_objectid);
	    break;

	case 'N':
	    /* get a file name */
	    recovered = 0;
	    if (sscanf (line, "%c %s\n", &code, name) != 2) {
		misc_die ("recover_file: wrong input N format");
	    }
	    fd = open (name, O_RDWR | O_CREAT | O_EXCL, 0644);
	    if (fd == -1)
		misc_die ("recover_file: could not create file %s: %s",
		     name,strerror (errno));
	    printf ("Recovering file %s..\n", name);
	    break;

	case 'B':
	    if (!fd)
		misc_die ("recover_file: file name is not specified");
	    if (sscanf (line, "%c %lu\n", &code, &block) != 2) {
		misc_die ("recover_file: wrong input B format");
	    }
	    bh = reiserfs_buffer_read (fs->s_dev, block, fs->s_blocksize);
	    if (!bh) {
		printf ("reading block %lu failed\n", block);
		continue;
	    }

	    printf ("working with block %lu..\n", block);

	    ih = reiserfs_ih_at (bh, 0);
	    for (i = 0; i < node_item_number (bh); i ++, ih ++) {
		__u32 * extent;
		reiserfs_bh_t * tmp_bh;

		if (!reiserfs_ih_ext (ih) || key.k_dir_id != ih->ih_key.k_dir_id ||
		    key.k_objectid != ih->ih_key.k_objectid)
		    continue;

		extent = (__u32 *)reiserfs_item_by_ih (bh, ih);
		for (j = 0; j < reiserfs_ext_count (ih); j ++) {
		    block = le32_to_cpu (extent [j]);
		    if (!block)
			continue;
		    tmp_bh = reiserfs_buffer_read (fs->s_dev, block, fs->s_blocksize);
		    if (!tmp_bh) {
			printf ("reading block %Lu failed\n", (long long int)block * fs->s_blocksize);
			continue;
		    }
		    if (lseek64 (fd, reiserfs_key_get_off (&ih->ih_key) + j * fs->s_blocksize - 1,
				 SEEK_SET) == (off_t)-1) {
			printf ("llseek failed to pos %Ld\n", (long long int)block * fs->s_blocksize);
			reiserfs_buffer_close (tmp_bh);
			continue;
		    }
		    if (reiserfs_bitmap_test_bit (bitmap, block))
			used ++;
		    else
			not_used ++;
		    /*printf ("block of file %Ld gets block %lu\n",
		      (reiserfs_key_get_off (&ih->ih_key) - 1) / fs->s_blocksize + j, block);*/
		    if (write (fd, tmp_bh->b_data, tmp_bh->b_size) != tmp_bh->b_size) {
			printf ("write failed to pos %Ld\n", (long long int)block * fs->s_blocksize);
			reiserfs_buffer_close (tmp_bh);
			continue;
		    }
		    recovered += fs->s_blocksize;
		    reiserfs_buffer_close (tmp_bh);
		}
	    }
	    reiserfs_buffer_close (bh);
	    break;
	}
    }
    printf ("recover_file: %Ld bytes recovered of file %s, key %u %u, %d blocks are free and %d are used\n",
	    recovered, name, key.k_dir_id, key.k_objectid, not_used, used);
}
#endif



/* read a file containing map of one or more files and either recover
   them or just print info */
/*
static void read_map (FILE * fp)
{
    int i;
    __u32 v32;
    char * buf;
    __u32 ids [4];
    int do_recover = 0;


    buf = 0;
    while (1) {
	if (fread (&v32, sizeof (v32), 1, fp) != 1)
	    break;
	if (v32 != MAP_MAGIC)
	    reiserfs_panic ("read_map: no magic found");

	// device name length and name itself 
	fread (&v32, sizeof (v32), 1, fp);
	buf = realloc (buf, v32);
	if (!buf)
	    reiserfs_panic ("realloc failed");
	fread (buf, v32, 1, fp);
	reiserfs_warning (stdout, "\"%s\": ", buf);

	// file name length and name itself
	fread (&v32, sizeof (v32), 1, fp);
	buf = realloc (buf, v32);
	if (!buf)
	    reiserfs_panic ("realloc failed");
	fread (buf, v32, 1, fp);

	// read directory key and poined object key 
	fread (ids, sizeof (ids), 1, fp);
	reiserfs_warning (stdout, "[%K]:\"%s\"-->[%K]\n",
			  &ids[0], buf, &ids[2]);

	
	//do_recover = util_user_confirmed (stdout, "recover? (Y):", "Y\n");
	//if (do_recover)
	//    reiserfs_warning (stderr, "recovering not ready\n");
	

	// how many data blocks are there 
	fread (&v32, sizeof (v32), 1, fp);
	if (v32) {
	    buf = realloc (buf, v32 * 4);
	    if (!buf)
		reiserfs_panic ("realloc failed (%u)", v32);
	    
	    // read list of data block numbers 
	    fread (buf, 4, v32, fp);
	    
	    if (!do_recover) {
		for (i = 0; i < v32; i ++)
		    reiserfs_warning (stdout, "%d ", ((__u32 *)buf)[i]);
		reiserfs_warning (stdout, "\n");
	    }
	}
	
	// main tail length 
	fread (&v32, sizeof (v32), 1, fp);
	if (v32) {
	    // there is tail 
	    buf = realloc (buf, v32);
	    if (!buf)
		reiserfs_panic ("realloc failed");
	    fread (buf, v32, 1, fp);
	    if (!do_recover)
		reiserfs_warning (stdout, "%d bytes long tail\n", v32);
	} else {
	    if (!do_recover)
		reiserfs_warning (stdout, "No tail\n");
	}

	if (fread (&v32, sizeof (v32), 1, fp) != 1)
	    break;
	if (v32 != MAP_END_MAGIC)
	    reiserfs_panic ("read_map: no magic found");
    }

    free (buf);
}


void do_recover (reiserfs_filsys_t * fs)
{
    FILE * fp;

    if (map_file (fs) [0] != '\0') {
	fp = fopen (map_file (fs), "r");
	if (fp == 0) {
	    reiserfs_warning (stderr, "do_recover: fopen failed: %m");
	    return;
	}
    } else {
	reiserfs_warning (stderr, "Reading file map from stdin..\n");
	fflush (stderr);
	fp = stdin;
    }

    read_map (fp);

    if (fp != stdin)
	fclose (fp);
    
}
*/

#include <limits.h>

static long int get_answer(long int max) {
    char answer[256], *tmp;    
    long int result = 0;

    do {
	printf("Which should be left?: ");
	fgets(answer, sizeof(answer), stdin);
	result = strtol (answer, &tmp, 0);
	if ((errno != ERANGE) && 
	    (result < max) && 
	    (result >= 0) &&
	    (answer != tmp))
	{
	    break;
	}
    } while (1);
    
    return result;
}

static void recover_items(FILE *fp, reiserfs_filsys_t * fs, FILE *target_file) {
    reiserfs_bh_t *bh, *bh_pointed;
    reiserfs_ih_t *ih;
    struct saved_item item, *cur;
    int size = sizeof(struct saved_item) - sizeof(struct saved_item *);
    struct saved_item *map = NULL;
    __u32 map_size = 0;
    int start = -1;
    unsigned int i, j;
    __u64 offset = 0, length;
    long int result = 0;
    unsigned long unfm_ptr;

    while (fread(&item, size, 1, fp) == 1) {
	map_size += sizeof(struct saved_item);
	map = realloc(map, map_size);
	memcpy((void *)map + map_size - sizeof(struct saved_item), &item, size);
    }
    
    for (i = 1, cur = map + 1; 
	 i <= map_size / sizeof(struct saved_item); 
	 i++, cur++) 
    {
	bh = reiserfs_buffer_read (fs->fs_dev, (cur - 1)->si_block, 
			     fs->fs_blocksize);
	if (!bh) {
	    reiserfs_warning (fp, "reiserfs_buffer_read failed\n");
	    continue;
	}

	if (i == map_size / sizeof(struct saved_item)) {
	    if (start != -1) {
		reiserfs_leaf_print(stdout, fs, bh, 0, 
				    (cur - 1)->si_item_num, 
				    (cur - 1)->si_item_num + 1);
		
		result = get_answer(i - start) + start;
	    } else {
		result = i - 1;
	    }
	    
	    start = -1;
	} else if (reiserfs_ih_dir(&(cur - 1)->si_ih) || 
		   reiserfs_ih_stat(&(cur - 1)->si_ih)) 
	{
	    reiserfs_buffer_close(bh);
	    continue;
	} else { 
	    length = reiserfs_leaf_ibytes(&(cur - 1)->si_ih, fs->fs_blocksize);
	    if (offset < reiserfs_key_get_off(&(cur - 1)->si_ih.ih_key) + 
		reiserfs_leaf_ibytes(&(cur - 1)->si_ih, fs->fs_blocksize))
		offset = reiserfs_key_get_off(&(cur - 1)->si_ih.ih_key) + 
			(length ? length - 1 : 0);
	
	    if (offset >= reiserfs_key_get_off(&cur->si_ih.ih_key)) {
		/* Problem interval */
		if (start == -1)
		    start = i - 1;
	    
		printf("Problem item %d:\n", i - start - 1);
		reiserfs_leaf_print(stdout, fs, bh, 0, 
				    (cur - 1)->si_item_num,
				    (cur - 1)->si_item_num + 1);
	    } else if (start != -1) {
		/* problem interval finished */
		printf("Problem item %d:\n", i - start - 1);
		reiserfs_leaf_print(stdout, fs, bh, 0, 
				    (cur - 1)->si_item_num,
				    (cur - 1)->si_item_num + 1);
	    
		result = get_answer((long int)i - start) + start;
		start = -1;
	    } else {
		result = i - 1;
	    }
	}
	reiserfs_buffer_close(bh);
	
	if (start != -1)
	    continue;

	bh = reiserfs_buffer_read (fs->fs_dev, (map + result)->si_block, 
			     fs->fs_blocksize);
	if (!bh) {
	    reiserfs_warning (fp, "reiserfs_buffer_read failed\n");
	    continue;
	}

	fseek(target_file, 
	      reiserfs_key_get_off(&(map + result)->si_ih.ih_key) - 1, 
	      SEEK_SET);
	
	ih = reiserfs_ih_at (bh, (map + result)->si_item_num);
	
	if (reiserfs_ih_direct(ih)) {
	    fwrite(reiserfs_item_by_ih(bh, ih), 
		   (map + result)->si_ih.ih2_item_len, 1, target_file);
	} else if (reiserfs_ih_ext(ih)) {
	    for (j = 0; j < reiserfs_ext_count (ih); j ++) {
		unfm_ptr = d32_get((__u32 *)reiserfs_item_by_ih(bh, ih), j);
		if (!unfm_ptr) {
		    fseek(target_file, fs->fs_blocksize, SEEK_CUR);
		    continue;
		}
		bh_pointed = reiserfs_buffer_read (fs->fs_dev, unfm_ptr, 
					     fs->fs_blocksize);
		if (!bh_pointed) {
		    reiserfs_warning (fp, "reiserfs_buffer_read failed\n");
		    continue;
		}
		fwrite(bh_pointed->b_data, 
		       fs->fs_blocksize, 1, target_file);
		
		reiserfs_buffer_close(bh_pointed);
	    }
	}
	
	reiserfs_buffer_close(bh);
    }

    free(map);
}

void do_recover(reiserfs_filsys_t * fs) {
    FILE *fp, *recovery;

    if (map_file (fs)[0] != '\0') {
	fp = fopen (map_file (fs), "r");
	if (fp == 0) {
	    reiserfs_warning (stderr, "fopen failed: %m\n");
	    return;
	}
    } else {
	reiserfs_warning (stderr, "Reading file map from stdin..\n");
	fflush (stderr);
	fp = stdin;
    }

    if (!(recovery = fopen(recovery_file(fs), "w+"))) {
	reiserfs_warning (stderr, "fopen failed: %m\n");
	return;
    }

    
    recover_items(fp, fs, recovery);
    
    if (fp != stdin)
	fclose (fp);
    
    fclose(recovery);
}