/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  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.
    *
   *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.plugin.opennap.util;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.RandomAccessFile;
  import java.util.StringTokenizer;
  
  import org.xnap.XNap;
  import org.xnap.io.Library;
  import org.xnap.io.MetaInfoFile;
  import org.xnap.util.Preferences;
  import org.xnap.util.StringHelper;
  
  
  public class OpenNapFileHelper
  {
  
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      //--- Constructor(s) ---
  
      //--- Method(s) ---
  
      /***
       * Converts the system-dependent pathname to the OpenNap format
       * which uses '\' as separator.
       */
      public static String getShareString(int index, File file) 
      {
  		if (Preferences.getInstance().getShareFullPath()){
  			String filename = file.getAbsolutePath();
  			return mapFilename(filename.replace(File.separatorChar, '//'));
  		}
  		else {
  			return index + "//" + mapFilename(file.getName());
  		}
      }
  
      /***
       * Extracts index and filename from OpenNap specific shared filename and
       * return file if it's a valid Shared entry.
       *
       * @return null, if filename is not part of repository
       */
      public static MetaInfoFile getSharedFileByIndex(String request) 
      {
  		StringTokenizer st = new StringTokenizer(request, "//");
  
  		if (st.countTokens() >= 2) {
  			try {
  				int index = Integer.parseInt(st.nextToken());
  				String filename = st.nextToken("").substring(1);
  
  				if (index >= 0 && index < Library.getInstance().size()) {
  					MetaInfoFile file = Library.getInstance().get(index);
  					if (file != null && file.isShared()
  						&& mapFilename(file.getName()).equals(filename)) {
  
  						return file;
  					}
  				}
  			}
  			catch (NumberFormatException e) {
  			}
  		}
  
  		return null;
      }
  
      /***
       * Retrieves repository file.
       * First we try to retrieve the file by parsing for its repository index,
       * if this does not work, we'll try to search for the file.
       */
      public static MetaInfoFile getSharedFile(String filename)
      {
  		MetaInfoFile file = getSharedFileByIndex(filename);
 		if (file != null) {
 			return file;
 		}
 
 		String shortname = StringHelper.lastToken(filename, "//");
 		MetaInfoFile[] results = Library.getInstance().search(shortname);
 
 		filename = filename.replace('//', File.separatorChar);
 		if (results != null) {
 			for (int i = 0; i < results.length; i++) {
 				if (mapFilename(results[i].getAbsolutePath()).equals(filename)
 					&& results[i].isShared()) {
 
 					return results[i];
 				}
 			}
 		}
     
 		return null;
     }
 
 	/***
 	 * @see Library#isShared(File) */
 	public static boolean isShared(File file)
 	{
 		return Library.getInstance().isShared(file);
 	}
 
 	/***
 	 * Replaces all characters that confuse OpenNap servers in
 	 * filename by non confusing characters. Used to send share
 	 * messages.
 	 */
 	public static String mapFilename(String filename)
 	{
 		//return filename.replace('"', '\uF020');
 		return filename.replace('"', '\'');
 	}
 
 	/***
 	 * Appends <code>inFile</code> to <code>outFile</code> starting at
 	 * <code>offset</code> off <code>inFile</code>
 	 */
 	public static void append(File outFile, File inFile, long offset) 
 		throws IOException
 	{
 		RandomAccessFile in = null;
 		RandomAccessFile out = null;
 		try {
 			out = new RandomAccessFile(outFile, "rw");
 			out.seek(out.length());
 
 			in = new RandomAccessFile(inFile, "r");
 			in.seek(offset);
 
 			// allocate 512 kb
 			byte[] data = new byte[512 * 1024];
 			long toWrite = in.length() - offset;
 			while (toWrite > 0) {
 				int len = (int)Math.min(data.length, toWrite);
 				in.readFully(data, 0, len);
 				out.write(data, 0, len);
 				toWrite -= len;
 			}
 	    }
 		finally {
 			if (in != null) {
 				try {
 					in.close();
 				}
 				catch (IOException e) {
 				}
 			}
 			if (out != null) {
 				try {
 					out.close();
 				}
 				catch (IOException e) {
 				}
 			}
 		}
 	}
 
 	public static void match(File f1, File f2, int byteCount) 
 		throws IOException
 	{
 		RandomAccessFile f1In = null;
 		RandomAccessFile f2In = null;
 		try {
 			f1In = new RandomAccessFile(f1, "r");
 			f2In = new RandomAccessFile(f2, "r");
 	
 			byte[] f1Data = new byte[byteCount];
 			f1In.seek(f1.length() - byteCount);
 			f1In.readFully(f1Data);
 
 			byte[] f2Data = new byte[byteCount];
 			f2In.seek(0);
 			f2In.readFully(f2Data);
 			
 			for (int i = 0; i < byteCount; i++) {
 				if (f1Data[i] != f2Data[i]) {
 					throw new IOException(XNap.tr("merge failed at {0}",
 												  new Integer(byteCount)));
 				}
 			}
 	    }
 		finally {
 			if (f1In != null) {
 				try {
 					f1In.close();
 				}
 				catch (IOException e) {
 				}
 			}
 			if (f2In != null) {
 				try {
 					f2In.close();
 				}
 				catch (IOException e) {
 				}
 			}
 		}
 
 	}
 
 
 }