package **********;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * Encode:UTF-8
 * 
 * Author:GFC
 * 
 * 根據輸入的url和設定的執行緒數，來完成斷點續傳功能。
 * 
 * 每個執行緒支負責某一小段的資料下載；再通過RandomAccessFile完成資料的整合。
 */




public class MultiTheradDownLoad {
	private String urlStr = null;
    private String filename = null;
    private String tmpfilename = null;

    private int threadNum = 0;

    private CountDownLatch latch = null;//設定一個計數器，程式碼內主要用來完成對快取檔案的刪除

    private long fileLength = 0l;
    private long threadLength = 0l;
    private long[] startPos;//保留每個執行緒下載資料的起始位置。
    private long[] endPos;//保留每個執行緒下載資料的截止位置。

    private boolean bool = false;

    private URL url = null;

    //有參建構函式，先構造需要的資料
    public MultiTheradDownLoad(String urlStr, int threadNum) {
        this.urlStr = urlStr;
        this.threadNum = threadNum;
        startPos = new long[this.threadNum];
        endPos = new long[this.threadNum];
        latch = new CountDownLatch(this.threadNum);
    }

    /*
     * 組織斷點續傳功能的方法
     */
    public void downloadPart() {

        File file = null;
        File tmpfile = null;
        
    	//設定HTTP網路訪問代理
    	System.setProperty("http.proxySet", "true");  
   		System.setProperty("http.proxyHost", "proxy3.bj.petrochina");  
 		System.setProperty("http.proxyPort", "8080"); 


        //從檔案連結中獲取檔名，此處沒考慮檔名為空的情況，此種情況可能需使用UUID來生成一個唯一數來代表檔名。
        filename = urlStr.substring(urlStr.lastIndexOf('/') + 1, urlStr
                .contains("?") ? urlStr.lastIndexOf('?') : urlStr.length());
        tmpfilename = filename + "_tmp";

        try {
        	//建立url
            url = new URL(urlStr);
            
            //開啟下載連結，並且得到一個HttpURLConnection的一個物件httpcon
            HttpURLConnection httpcon = (HttpURLConnection) url.openConnection();
            httpcon.setRequestMethod("GET");
            
            //獲取請求資源的總長度。
            fileLength = httpcon.getContentLengthLong();

            //下載檔案和臨時檔案
            file = new File(filename);//相對目錄
            tmpfile = new File(tmpfilename);

            //每個執行緒需下載的資源大小；由於檔案大小不確定，為避免資料丟失
            threadLength = fileLength%threadNum == 0 ? fileLength/threadNum : fileLength/threadNum+1;
            //列印下載資訊
            System.out.println("fileName: " + filename + " ," + "fileLength= "
                    + fileLength + " the threadLength= " + threadLength);
            
            //各個執行緒在exec執行緒池中進行，起始位置--結束位置
            if (file.exists() && file.length() == fileLength) {
                System.out.println("檔案已存在!!");
                return;
            } else {
                setBreakPoint(startPos, endPos, tmpfile);
                ExecutorService exec = Executors.newCachedThreadPool();
                for (int i = 0; i < threadNum; i++) {
                    exec.execute(new DownLoadThread(startPos[i], endPos[i],
                            this, i, tmpfile, latch));
                }
                latch.await();//當你的計數器減為0之前，會在此處一直阻塞。
                exec.shutdown();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //下載完成後，判斷檔案是否完整，並刪除臨時檔案
        if (file.length() == fileLength) {
            if (tmpfile.exists()) {
                System.out.println("刪除臨時檔案!!");
                tmpfile.delete();
            }
        }
    }

    /*
     * 斷點設定方法，當有臨時檔案時，直接在臨時檔案中讀取上次下載中斷時的斷點位置。沒有臨時檔案，即第一次下載時，重新設定斷點。
     * 
     * Rantmpfile.seek()跳轉到一個位置的目的是為了讓各個斷點儲存的位置儘量分開。
     * 
     * 這是實現斷點續傳的重要基礎。
     */
    private void setBreakPoint(long[] startPos, long[] endPos, File tmpfile) {
        RandomAccessFile rantmpfile = null;
        try {
            if (tmpfile.exists()) {
                System.out.println("繼續下載!!");
                rantmpfile = new RandomAccessFile(tmpfile, "rw");
                for (int i = 0; i < threadNum; i++) {
                    rantmpfile.seek(8 * i + 8);
                    startPos[i] = rantmpfile.readLong();

                    rantmpfile.seek(8 * (i + 1000) + 16);
                    endPos[i] = rantmpfile.readLong();

                    System.out.println("the Array content in the exit file: ");
                    System.out.println("thre thread" + (i + 1) + " startPos:"
                            + startPos[i] + ", endPos: " + endPos[i]);
                }
            } else {
                System.out.println("the tmpfile is not available!!");
                rantmpfile = new RandomAccessFile(tmpfile, "rw");
                
                //最後一個執行緒的截止位置大小為請求資源的大小
                for (int i = 0; i < threadNum; i++) {
                    startPos[i] = threadLength * i;
                    if (i == threadNum - 1) {
                        endPos[i] = fileLength;
                    } else {
                        endPos[i] = threadLength * (i + 1) - 1;
                    }

                    rantmpfile.seek(8 * i + 8);
                    rantmpfile.writeLong(startPos[i]);

                    rantmpfile.seek(8 * (i + 1000) + 16);
                    rantmpfile.writeLong(endPos[i]);

                    System.out.println("the Array content: ");
                    System.out.println("thre thread" + (i + 1) + " startPos:"
                            + startPos[i] + ", endPos: " + endPos[i]);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rantmpfile != null) {
                    rantmpfile.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /*
     * 實現下載功能的內部類，通過讀取斷點來設定向伺服器請求的資料區間。
     */
    class DownLoadThread implements Runnable {

        private long startPos;
        private long endPos;
        private MultiTheradDownLoad task = null;
        private RandomAccessFile downloadfile = null;
        private int id;
        private File tmpfile = null;
        private RandomAccessFile rantmpfile = null;
        private CountDownLatch latch = null;

        public DownLoadThread(long startPos, long endPos,
                MultiTheradDownLoad task, int id, File tmpfile,
                CountDownLatch latch) {
            this.startPos = startPos;
            this.endPos = endPos;
            this.task = task;
            this.tmpfile = tmpfile;
            try {
            	//
                this.downloadfile = new RandomAccessFile(this.task.filename,"rw");
                this.rantmpfile = new RandomAccessFile(this.tmpfile, "rw");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            this.id = id;
            this.latch = latch;
        }

        @Override
        public void run() {

            HttpURLConnection httpcon = null;
            InputStream is = null;
            int length = 0;

            System.out.println("執行緒" + id + " 開始下載!!");

            while (true) {
                try {
                    httpcon = (HttpURLConnection) task.url.openConnection();
                    httpcon.setRequestMethod("GET");
                    
                    //防止網路阻塞，設定指定的超時時間；單位都是ms。超過指定時間，就會丟擲異常
                    httpcon.setReadTimeout(20000);//讀取資料的超時設定
                    httpcon.setConnectTimeout(20000);//連線的超時設定

                    if (startPos < endPos) {
                        
                        //向伺服器請求指定區間段的資料，這是實現斷點續傳的根本。
                        httpcon.setRequestProperty("Range", "bytes=" + startPos+ "-" + endPos);

                        System.out.println("執行緒 " + id+ " 長度:---- "+ (endPos - startPos));

                        downloadfile.seek(startPos);

                        if (httpcon.getResponseCode() != HttpURLConnection.HTTP_OK
                                && httpcon.getResponseCode() != HttpURLConnection.HTTP_PARTIAL) {
                            this.task.bool = true;
                            httpcon.disconnect();
                            downloadfile.close();
                            System.out.println("執行緒 ---" + id + " 下載完成!!");
                            latch.countDown();//計數器自減
                            break;
                        }

                        is = httpcon.getInputStream();//獲取伺服器返回的資源流
                        long count = 0l;
                        byte[] buf = new byte[1024];

                        while (!this.task.bool && (length = is.read(buf)) != -1) {
                            count += length;
                            downloadfile.write(buf, 0, length);
                            
                            //不斷更新每個執行緒下載資源的起始位置，並寫入臨時檔案；為斷點續傳做準備
                            startPos += length;
                            rantmpfile.seek(8 * id + 8);
                            rantmpfile.writeLong(startPos);
                        }
                        System.out.println("執行緒 " + id
                                + " 總下載大小: " + count);
                        
                        //關閉流
                        is.close();
                        httpcon.disconnect();
                        downloadfile.close();
                        rantmpfile.close();
                    }
                    latch.countDown();//計數器自減
                    System.out.println("執行緒 " + id + " 下載完成!!");
                    break;
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if (is != null) {
                            is.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}