/*
Copyright (c) 2006 Joseph Gleason

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Current versions of this and other code can be downloaded at:
http://gleason.cc/

*/
package cc.glsn.v15;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
import java.util.Scanner;

import cc.glsn.Util;

public class ParanoidFileCopy
{
    public static final int BlockSize=128*1024;
    public static final int BlockCount=20*1024*1024/BlockSize;
    
    
    private PCMonitor<Block> In2MD;
    private PCMonitor<Block> MD2Out;
    private PCMonitor<Block> Out2In;

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        if (args.length !=4 )
        {
            System.out.println("Syntax: ParanoidFileCopy <srcdir> <dstdir> <file> <md5path>");
            System.exit(-1);
        }
        String SrcDir=args[0];
        String DstDir=args[1];
        String FileBase=args[2];
        String MD5Path=args[3];
        
        new ParanoidFileCopy(SrcDir,DstDir,FileBase,MD5Path);
        

    }
    
    public ParanoidFileCopy(String SrcDir, String DstDir, String FileBase, String MD5Path)
    {
        In2MD=new PCMonitor<Block>();
        MD2Out=new PCMonitor<Block>();
        Out2In=new PCMonitor<Block>();
        for(int i=0; i<BlockCount; i++)
        {
            Out2In.produce(new Block());
        }
        
        
        Random PRNG=new Random();
        
        File Input=new File(SrcDir + "/" + FileBase);
        File Output=new File(DstDir + "/" + FileBase);
        File OutputTmp=new File(DstDir + "/" + Long.toHexString(PRNG.nextLong()) +".tmp");
        OutputTmp.deleteOnExit();
        
        
        
        
        InputThread ipt=new InputThread(Input);
        ipt.start();
        
        MDThread mdt=new MDThread();
        mdt.start();
        
        OutputThread opt=new OutputThread(OutputTmp);
        opt.start();
        
        System.out.println(FileBase + ": Copy started...");
        
        
        File OrigMD5File=new File(MD5Path +"/" + FileBase + ".md5");
        String OrigMD5=null;
        if (OrigMD5File.exists())
        {
            try
            {
                String S=Util.readInputStream(new FileInputStream(OrigMD5File));
                Scanner Scan=new Scanner(S);
                OrigMD5=Scan.next();
            }
            catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
        }
        
        while ((ipt.isAlive()) || (mdt.isAlive()) || (opt.isAlive()))
        {
            try
            {
                Thread.sleep(2000);
                //System.out.println("" + In2MD.getQueueSize() + ":" + MD2Out.getQueueSize() + ":" + Out2In.getQueueSize());  
                
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        
        if (OrigMD5==null)
        {
            PrintStream ps;
            try
            {
                ps = new PrintStream(new FileOutputStream(OrigMD5File));
                ps.println(mdt.MD5Sum);
                ps.flush();
                ps.close();
                
            }
            catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            System.out.println(FileBase + ": No original md5 file.  Created: " + mdt.MD5Sum);
        }
        else
        {
            if (!OrigMD5.equals(mdt.MD5Sum))
            {
                System.out.println("Error: MD5 Mismatch.");
                System.out.println("MD5 File:  " + OrigMD5);
                System.out.println("Read File: " + mdt.MD5Sum);
                System.exit(-1);
            }
            else
            {
                System.out.println(FileBase + ": MD5 Read Match: " + mdt.MD5Sum);
            }
        }
        
        try
        {
            String WroteFileMD5=Util.MD5File(OutputTmp);
            if (!mdt.MD5Sum.equals(WroteFileMD5))
            {
                System.out.println("Error: MD5 Mismatch.");
                System.out.println("Read File:  " + mdt.MD5Sum);
                System.out.println("Wrote File: " + WroteFileMD5);
                System.exit(-1);
            }
            else
            {
                System.out.println(FileBase +": MD5 Write Match: " + WroteFileMD5);
            }
            
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.exit(-1);
        }

        
        if(OutputTmp.renameTo(Output))
        {
            System.out.println(FileBase + ": Copy complete");
        }
        else
        {
            System.out.println("Error: Temp file rename failed");
            System.exit(-1);
        }
        
        
        
        
        
    }
    
    
    class Block
    {
        int Filled;
        byte[] Data;
        boolean LastBlock;
        
        public Block()
        {
            Filled=0;
            Data=new byte[BlockSize];
            LastBlock=false;
            
        }
        
        public void clear()
        {
            Filled=0;
            LastBlock=false;
        }
        
        
    }
    
    class InputThread extends Thread
    {
        File InFile;
        public InputThread(File InFile)
        {
            this.InFile=InFile;
            
        }
        
        public void run()
        {
            if (!InFile.exists())
            {
                System.out.println("Input file: " + InFile + " does not exist.");
                System.exit(-1);
            }
            try
            {
                FileInputStream FIS=new FileInputStream(InFile);
                long TotalSz=InFile.length();
                long Sz=0;
                while(Sz < TotalSz)
                {
                    Block B=Out2In.consume();
                    B.clear();
                    while((Sz < TotalSz) && (B.Filled < BlockSize))
                    {
                        int MaxRead=new Long(Math.min(TotalSz - Sz, BlockSize-B.Filled)).intValue();
                        
                        int r=FIS.read(B.Data,B.Filled,MaxRead);
                        if (r>0)
                        {
                            Sz+=r;
                            B.Filled+=r;
                        }
                        else
                        {
                            System.out.println("End of input file reached before all bytes read!");
                            System.exit(-1);
                            
                        }
                        
                    }
                    if (Sz==TotalSz)
                    {
                        B.LastBlock=true;
                    }
                    In2MD.produce(B);
                    
                }
                
                
            }
            catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
        }
        
    }
    class MDThread extends Thread
    {
        public String MD5Sum;
        public MDThread()
        {
            
            
        }
        
        public void run()
        {
            try
            {
                MessageDigest SIG=MessageDigest.getInstance("MD5");
                
                boolean LastBlockSeen=false;
                while(!LastBlockSeen)
                {
                    Block B=In2MD.consume();
                    SIG.update(B.Data,0,B.Filled);
                    if (B.LastBlock) LastBlockSeen=true;
                    MD2Out.produce(B);
                }
                
                byte D[]=SIG.digest();

                StringBuilder S=new StringBuilder(32);
                BigInteger BI=new BigInteger(1,D);

                S.append(BI.toString(16));
                while (S.length() < 32)
                {
                    S.insert(0,'0');
                }
                MD5Sum=S.toString();
                
                

                
                
            }
            catch (NoSuchAlgorithmException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            
        }
        
    }
        
    class OutputThread extends Thread
    {
        File OutFile;
        public OutputThread(File OutFile)
        {
            this.OutFile=OutFile;
            
        }
        
        public void run()
        {
            try
            {
                BufferedOutputStream FOS=new BufferedOutputStream(new FileOutputStream(OutFile),BlockSize*3);
                boolean LastBlockSeen=false;
                while(!LastBlockSeen)
                {
                    Block B=MD2Out.consume();
                    
                    FOS.write(B.Data,0,B.Filled);
                    if (B.LastBlock) LastBlockSeen=true;
                    B.clear();
                    Out2In.produce(B);
                }
                FOS.flush();
                FOS.close();
                
                
            }
            catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.exit(-1);
            }
            
        }
        
    }
    

}