using System;
using System.Security.Principal;
using System.Threading;
using System.Collections;
using System.Collections.Generic;

class ADPrincipal
{
    static void Main(string[] args)
    {                
        string[] filePah = new string[20];
        for(int i=0;i<20;i++)
        {
            filePah[i]=i+"";
        }
        DownloadManager manager = new DownloadManager(filePah,5);
        string cmd;
        while((cmd=Console.ReadLine())!="end")
        {
            switch (cmd)
            {
                case "pause":
                    {
                        manager.Pause();
                        break;
                    }
                case "start":
                    {
                        manager.Start();
                        break;
                    }
                case "restart":
                    {
                        manager.Restart();
                        break;
                    }
                case "stop":
                    {
                        manager.Stop();
                        break;
                    }
                case "disposable":
                    {
                        manager.Dispose();
                        break;
                    }
            }
        }
    }
}

/// <summary>
/// 管理类
/// </summary>
public class DownloadManager:IDisposable
{
    private List<string> fileList;
    private List<DownloadWork> workList;
    private E_State state;
    private int perPath;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="filePaths">下载的所有路径</param>
    /// <param name="perPath">每个线程需要执行的路径数量</param>
    public DownloadManager(string[] filePaths,int perPath)
    {
        this.state = E_State.Stop;
        this.fileList = new List<string>(filePaths.Length);        
        foreach (string path in filePaths)
        {
            this.fileList.Add(path);
        }
        this.perPath = perPath;
    }

    /// <summary>
    /// 执行下载
    /// </summary>
    /// <param name="perPath">表示每个线程处理几个路径</param>
    private void Execute(int perPath)
    {
        this.state = E_State.Download;
        int threadCount = this.fileList.Count % perPath == 0 ? this.fileList.Count / perPath : this.fileList.Count / perPath + 1;
        workList = new List<DownloadWork>(7);
        DownloadWork work;
        Thread thread;
        List<string> pathList = new List<string>(perPath);        
        int j=1,i=1;
        foreach(string path in this.fileList)
        {
            pathList.Add(path);
            if (i == j * perPath || i == this.fileList.Count)
            {                
                work = new DownloadWork(pathList.ToArray());
                thread = new Thread(new ThreadStart(work.Execute));
                work.CurrentThread = thread;
                workList.Add(work);
                pathList.Clear();
                j++;

                thread.Start();
            }
            i++;
        }                                    
    }

    
    /// <summary>
    /// 开始下载
    /// </summary>
    public void Start()
    {
        if (this.state != E_State.Stop||this.fileList.Count==0)
        {
            throw new Exception("已经开始下载或没有路径");
        }

        this.Execute(this.perPath);
    }

    /// <summary>
    /// 继续下载
    /// </summary>
    public void Restart()
    {
        if (this.state != E_State.Pause)
        {
            throw new Exception("没有暂停下载");
        }

        this.Execute(this.perPath);
    }

    /// <summary>
    /// 停止整个下载过程
    /// </summary>
    public void Stop()
    {        
        this.state = E_State.Stop;
        foreach (DownloadWork work in workList)
        {
            work.Abort();
        }
        this.fileList.Clear();
        this.workList.Clear();
    }

    private void RemovePath(List<string> doneList)
    {
        foreach (string path in doneList)
        {
            this.fileList.Remove(path);
        }
    }

    /// <summary>
    /// 暂停下载过程
    /// </summary>
    public void Pause()
    {        
        this.state = E_State.Pause;
        foreach (DownloadWork work in this.workList)
        {
            work.Abort();
            //删除已经下载过的路径
            this.RemovePath(work.DonePaths);            
        }
        workList.Clear();
    }

    #region IDisposable 成员

    public void Dispose()
    {
        this.Stop();   
    }

    #endregion

    enum E_State
    {
        Stop,
        Download,
        Pause
    }
}


/// <summary>
/// 执行类
/// </summary>
public class DownloadWork
{
    private string[] paths;
    public List<string> DonePaths;   
    private Thread currentThread;
    public Thread CurrentThread
    {
        set
        {
            this.currentThread = value;
        }
    }

    public DownloadWork(string[] paths)
    {
        this.paths = paths;
        this.DonePaths = new List<string>(paths.Length);
    }

    public void Execute()
    {
        //测试用
        Thread.Sleep(1000 * 5);
        foreach (string path in this.paths)
        {
            //根据路径来下载,这里用输出代替                                
            Console.WriteLine(path);   
         
            //更新已下载        
            DonePaths.Add(path);

            //测试用
            Thread.Sleep(1000);
        }
    }

    /// <summary>
    /// 终止线程
    /// </summary>
    public void Abort()
    {
        try
        {
            if (this.currentThread.ThreadState != ThreadState.Stopped)
            {
                this.currentThread.Abort();
            }
        }
        catch
        {
        }
    }
}