//! Messaging primitives for announcing.

use std::io::{self, Write};
use std::net::{Ipv4Addr, Ipv6Addr};

use bip_util::bt::{self, InfoHash, PeerId};
use bip_util::convert::{self};
use byteorder::{WriteBytesExt, BigEndian};
use nom::{IResult, be_i32, be_i64, be_u32, be_u16, be_u8};

use contact::{CompactPeers};
use option::{AnnounceOptions};

const IMPLIED_IPV4_ID: [u8; 4]  = [0u8; 4];
const IMPLIED_IPV6_ID: [u8; 16] = [0u8; 16];

const DEFAULT_NUM_WANT: i32 = -1;

const ANNOUNCE_NONE_EVENT:      i32 = 0;
const ANNOUNCE_COMPLETED_EVENT: i32 = 1;
const ANNOUNCE_STARTED_EVENT:   i32 = 2;
const ANNOUNCE_STOPPED_EVENT:   i32 = 3;

/// Announce request sent from the client to the server.
///
/// IPv6 is supported but is [not standard](http://opentracker.blog.h3q.com/2007/12/28/the-ipv6-situation/).
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AnnounceRequest<'a> {
    info_hash: InfoHash,
    peer_id:   PeerId,
    state:     ClientState,
    ip:        SourceIP,
    key:       u32,
    num_want:  DesiredPeers,
    port:      u16,
    options:   AnnounceOptions<'a>
}

impl<'a> AnnounceRequest<'a> {
    /// Create a new AnnounceRequest.
    pub fn new(hash: InfoHash, peer_id: PeerId, state: ClientState, ip: SourceIP, key: u32,
        num_want: DesiredPeers, port: u16, options: AnnounceOptions<'a>) -> AnnounceRequest<'a> {
        AnnounceRequest{ info_hash: hash, peer_id: peer_id, state: state, ip: ip, key: key,
            num_want: num_want, port: port, options: options }
    }

    /// Construct an IPv4 AnnounceRequest from the given bytes.
    pub fn from_bytes_v4(bytes: &'a [u8]) -> IResult<&'a [u8], AnnounceRequest<'a>> {
        parse_request(bytes, SourceIP::from_bytes_v4)
    }
    
    /// Construct an IPv6 AnnounceRequest from the given bytes.
    pub fn from_bytes_v6(bytes: &'a [u8]) -> IResult<&'a [u8], AnnounceRequest<'a>> {
        parse_request(bytes, SourceIP::from_bytes_v6)
    }
    
    /// Write the AnnounceRequest to the given writer.
    pub fn write_bytes<W>(&self, mut writer: W) -> io::Result<()>
        where W: Write {
        try!(writer.write_all(self.info_hash.as_ref()));
        try!(writer.write_all(self.peer_id.as_ref()));
        
        try!(self.state.write_bytes(&mut writer));
        try!(self.ip.write_bytes(&mut writer));
        
        try!(writer.write_u32::<BigEndian>(self.key));
        
        try!(self.num_want.write_bytes(&mut writer));
        
        try!(writer.write_u16::<BigEndian>(self.port));
        
        try!(self.options.write_bytes(&mut writer));
        
        Ok(())
    }
    
    /// InfoHash of the current request.
    pub fn info_hash(&self) -> InfoHash {
        self.info_hash
    }
    
    /// PeerId of the current request.
    pub fn peer_id(&self) -> PeerId {
        self.peer_id
    }
    
    /// State reported by the client in the given request.
    pub fn state(&self) -> ClientState {
        self.state
    }
    
    /// Source address to send the response to.
    pub fn source_ip(&self) -> SourceIP {
        self.ip
    }
    
    /// Unique key randomized by the client that the server can use.
    pub fn key(&self) -> u32 {
        self.key
    }
    
    /// Number of peers desired by the client.
    pub fn num_want(&self) -> DesiredPeers {
        self.num_want
    }
    
    /// Port to send the response to.
    pub fn port(&self) -> u16 {
        self.port
    }
    
    /// Set of AnnounceOptions supplied in the request.
    pub fn options(&self) -> &AnnounceOptions<'a> {
        &self.options
    }
    
    /// Create an owned version of AnnounceRequest.
    pub fn to_owned(&self) -> AnnounceRequest<'static> {
        // Do not call clone and simply switch out the AnnounceOptions as that would
        // unecessarily allocate a HashMap with shallowly cloned Cow objects which
        // is superfulous.
        let owned_options = self.options.to_owned();
        
        AnnounceRequest{ info_hash: self.info_hash, peer_id: self.peer_id, state: self.state, ip: self.ip,
            key: self.key, num_want: self.num_want, port: self.port, options: owned_options }
    }
}

/// Parse an AnnounceRequest with the given SourceIP type constructor.
fn parse_request<'a>(bytes: &'a [u8], ip_type: fn(bytes: &[u8]) -> IResult<&[u8], SourceIP>)
    -> IResult<&'a [u8], AnnounceRequest<'a>> {
    chain!(bytes,
        info_hash:  map!(take!(bt::INFO_HASH_LEN), |bytes| InfoHash::from_hash(bytes).unwrap()) ~
        peer_id:    map!(take!(bt::PEER_ID_LEN), |bytes| PeerId::from_hash(bytes).unwrap()) ~
        state:   call!(ClientState::from_bytes) ~
        ip:         call!(ip_type) ~
        key:        be_u32 ~
        num_want:   call!(DesiredPeers::from_bytes) ~
        port:       be_u16 ~
        options:    call!(AnnounceOptions::from_bytes) ,
        || { AnnounceRequest::new(info_hash, peer_id, state, ip, key, num_want, port, options) }
    )
}

//----------------------------------------------------------------------------//

/// Announce response sent from the server to the client.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AnnounceResponse<'a> {
    interval: i32,
    leechers: i32,
    seeders:  i32,
    peers:    CompactPeers<'a>
}

impl<'a> AnnounceResponse<'a> {
    /// Create a new AnnounceResponse
    pub fn new(interval: i32, leechers: i32, seeders: i32, peers: CompactPeers<'a>) -> AnnounceResponse<'a> {
        AnnounceResponse{ interval: interval, leechers: leechers, seeders: seeders, peers: peers }
    }
    
    /// Construct an IPv4 AnnounceResponse from the given bytes.
    pub fn from_bytes_v4(bytes: &'a [u8]) -> IResult<&'a [u8], AnnounceResponse<'a>> {
        parse_respone(bytes, CompactPeers::from_bytes_v4)
    }
    
    /// Construct an IPv6 AnnounceResponse from the given bytes.
    pub fn from_bytes_v6(bytes: &'a [u8]) -> IResult<&'a [u8], AnnounceResponse<'a>> {
        parse_respone(bytes, CompactPeers::from_bytes_v6)
    }
    
    /// Write the AnnounceResponse to the given writer.
    pub fn write_bytes<W>(&self, mut writer: W) -> io::Result<()>
        where W: Write {
        try!(writer.write_i32::<BigEndian>(self.interval));
        try!(writer.write_i32::<BigEndian>(self.leechers));
        try!(writer.write_i32::<BigEndian>(self.seeders));
        
        try!(self.peers.write_bytes(&mut writer));
        
        Ok(())
    }
    
    /// Interval in seconds that clients should wait before re-announcing.
    pub fn interval(&self) -> i32 {
        self.interval
    }
    
    /// Number of leechers the tracker knows about for the torrent.
    pub fn leechers(&self) -> i32 {
        self.leechers
    }
    
    /// Number of seeders the tracker knows about for the torrent.
    pub fn seeders(&self) -> i32 {
        self.seeders
    }
    
    /// Peers the tracker knows about that are sharing the torrent.
    pub fn peers(&self) -> &CompactPeers<'a> {
        &self.peers
    }
    
    /// Create an owned version of AnnounceResponse.
    pub fn to_owned(&self) -> AnnounceResponse<'static> {
        let owned_peers = self.peers().to_owned();
        
        AnnounceResponse{ interval: self.interval, leechers: self.leechers, seeders: self.seeders,
            peers: owned_peers }
    }
}

/// Parse an AnnounceResponse with the given CompactPeers type constructor.
fn parse_respone<'a>(bytes: &'a [u8], peers_type: fn(bytes: &'a [u8]) -> IResult<&'a [u8], CompactPeers<'a>>)
    -> IResult<&'a [u8], AnnounceResponse<'a>> {
    chain!(bytes,
        interval: be_i32 ~
        leechers: be_i32 ~
        seeders:  be_i32 ~
        peers:    call!(peers_type) ,
        || { AnnounceResponse::new(interval, leechers, seeders, peers) }
    )
}

//----------------------------------------------------------------------------//

/// Announce state of a client reported to the server.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct ClientState {
    downloaded: i64,
    left:       i64,
    uploaded:   i64,
    event:      AnnounceEvent
}

impl ClientState {
    /// Create a new ClientState.
    pub fn new(bytes_downloaded: i64, bytes_left: i64, bytes_uploaded: i64, event: AnnounceEvent) -> ClientState {
        ClientState{ downloaded: bytes_downloaded, left: bytes_left, uploaded: bytes_uploaded, event: event }
    }
    
    /// Construct the ClientState from the given bytes.
    pub fn from_bytes(bytes: &[u8]) -> IResult<&[u8], ClientState> {
        parse_state(bytes)
    }
    
    /// Write the ClientState to the given writer.
    pub fn write_bytes<W>(&self, mut writer: W) -> io::Result<()>
        where W: Write {
        try!(writer.write_i64::<BigEndian>(self.downloaded));
        try!(writer.write_i64::<BigEndian>(self.left));
        try!(writer.write_i64::<BigEndian>(self.uploaded));
        
        try!(self.event.write_bytes(&mut writer));
        
        Ok(())
    }
    
    /// Event reported by the client.
    pub fn event(&self) -> AnnounceEvent {
        self.event
    }
    
    /// Bytes left to be downloaded.
    pub fn bytes_left(&self) -> i64 {
        self.left
    }
    
    /// Bytes already uploaded.
    pub fn bytes_uploaded(&self) -> i64 {
        self.uploaded
    }
    
    /// Bytes already downloaded.
    pub fn bytes_downloaded(&self) -> i64 {
        self.downloaded
    }
}

fn parse_state(bytes: &[u8]) -> IResult<&[u8], ClientState> {
    chain!(bytes,
        downloaded: be_i64 ~
        left:       be_i64 ~
        uploaded:   be_i64 ~
        event:      call!(AnnounceEvent::from_bytes) ,
        || { ClientState::new(downloaded, left, uploaded, event) }
    )
}

//----------------------------------------------------------------------------//

/// Announce event of a client reported to the server.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum AnnounceEvent {
    /// No event is reported.
    None,
    /// Torrent download has completed.
    Completed,
    /// Torrent download has started.
    Started,
    /// Torrent download has stopped.
    Stopped
}

impl AnnounceEvent {
    /// Construct an AnnounceEvent from the given bytes.
    pub fn from_bytes(bytes: &[u8]) -> IResult<&[u8], AnnounceEvent> {
        parse_event(bytes)
    }
    
    /// Write the AnnounceEvent to the given writer.
    pub fn write_bytes<W>(&self, mut writer: W) -> io::Result<()>
        where W: Write {
        try!(writer.write_i32::<BigEndian>(self.as_id()));
        
        Ok(())
    }
    
    /// Access the raw id of the current event.
    pub fn as_id(&self) -> i32 {
        match self {
            &AnnounceEvent::None      => ANNOUNCE_NONE_EVENT,
            &AnnounceEvent::Completed => ANNOUNCE_COMPLETED_EVENT,
            &AnnounceEvent::Started   => ANNOUNCE_STARTED_EVENT,
            &AnnounceEvent::Stopped   => ANNOUNCE_STOPPED_EVENT
        }
    }
}

fn parse_event(bytes: &[u8]) -> IResult<&[u8], AnnounceEvent> {
    switch!(bytes, be_i32,
        ANNOUNCE_NONE_EVENT      => value!(AnnounceEvent::None)      |
        ANNOUNCE_COMPLETED_EVENT => value!(AnnounceEvent::Completed) |
        ANNOUNCE_STARTED_EVENT   => value!(AnnounceEvent::Started)   |
        ANNOUNCE_STOPPED_EVENT   => value!(AnnounceEvent::Stopped)
    )
}

//----------------------------------------------------------------------------//

/// Client specified IP address to send the response to.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum SourceIP {
    /// Infer the IPv4 address from the sender address.
    ImpliedV4,
    /// Send the response to the given IPv4 address.
    ExplicitV4(Ipv4Addr),
    /// Infer the IPv6 address from the sender address.
    ImpliedV6,
    /// Send the response to the given IPv6 address.
    ExplicitV6(Ipv6Addr)
}

impl SourceIP {
    /// Construct the IPv4 SourceIP from the given bytes.
    pub fn from_bytes_v4(bytes: &[u8]) -> IResult<&[u8], SourceIP> {
        parse_preference_v4(bytes)
    }
    
    /// Construct the IPv6 SourceIP from the given bytes.
    pub fn from_bytes_v6(bytes: &[u8]) -> IResult<&[u8], SourceIP> {
        parse_preference_v6(bytes)
    }
    
    /// Write the SourceIP to the given writer.
    pub fn write_bytes<W>(&self, writer: W) -> io::Result<()>
        where W: Write {
        match self {
            &SourceIP::ImpliedV4        => self.write_bytes_slice(writer, &IMPLIED_IPV4_ID[..]),
            &SourceIP::ImpliedV6        => self.write_bytes_slice(writer, &IMPLIED_IPV6_ID[..]),
            &SourceIP::ExplicitV4(addr) => self.write_bytes_slice(writer, &convert::ipv4_to_bytes_be(addr)[..]),
            &SourceIP::ExplicitV6(addr) => self.write_bytes_slice(writer, &convert::ipv6_to_bytes_be(addr)[..]),
        }
    }
    
    /// Whether or not the source is an IPv6 address.
    pub fn is_ipv6(&self) -> bool {
        match self {
            &SourceIP::ImpliedV6     => true,
            &SourceIP::ExplicitV6(_) => true,
            &SourceIP::ImpliedV4     => false,
            &SourceIP::ExplicitV4(_) => false
        }
    }
    
    /// Whether or not the source is an IPv4 address.
    pub fn is_ipv4(&self) -> bool {
        !self.is_ipv6()
    }
    
    /// Write the given byte slice to the given writer.
    fn write_bytes_slice<W>(&self, mut writer: W, bytes: &[u8]) -> io::Result<()>
        where W: Write {
        writer.write_all(bytes)
    }
}

fn parse_preference_v4(bytes: &[u8]) -> IResult<&[u8], SourceIP> {
    alt!(bytes,
        tag!(IMPLIED_IPV4_ID) => { |_| SourceIP::ImpliedV4 } |
        parse_ipv4            => { |ipv4| SourceIP::ExplicitV4(ipv4) }
    )
}

named!(parse_ipv4<&[u8], Ipv4Addr>,
    map!(count_fixed!(u8, be_u8, 4), |b| convert::bytes_be_to_ipv4(b))
);

fn parse_preference_v6(bytes: &[u8]) -> IResult<&[u8], SourceIP> {
    alt!(bytes,
        tag!(IMPLIED_IPV6_ID) => { |_| SourceIP::ImpliedV6 } |
        parse_ipv6            => { |ipv6| SourceIP::ExplicitV6(ipv6) }
    )
}

named!(parse_ipv6<&[u8], Ipv6Addr>,
    map!(count_fixed!(u8, be_u8, 16), |b| convert::bytes_be_to_ipv6(b))
);

//----------------------------------------------------------------------------//

/// Client desired number of peers to send in the response.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum DesiredPeers {
    /// Send the default number of peers.
    Default,
    /// Send a specific number of peers.
    Specified(i32)
}

impl DesiredPeers {
    /// Construct the DesiredPeers from the given bytes.
    pub fn from_bytes(bytes: &[u8]) -> IResult<&[u8], DesiredPeers> {
        parse_desired(bytes)
    }
    
    /// Write the DesiredPeers to the given writer.
    pub fn write_bytes<W>(&self, mut writer: W) -> io::Result<()>
        where W: Write {
        let write_value = match self {
            &DesiredPeers::Default          => DEFAULT_NUM_WANT,
            &DesiredPeers::Specified(count) => count
        };
        try!(writer.write_i32::<BigEndian>(write_value));
        
        Ok(())
    }
}

fn parse_desired(bytes: &[u8]) -> IResult<&[u8], DesiredPeers> {
    // Tuple trick used to subvert the unused pattern warning (nom tries to catch all)
    switch!(bytes, tuple!(be_i32, value!(true)),
        (DEFAULT_NUM_WANT, true) => value!(DesiredPeers::Default) |
        (specified_peers, true)  => value!(DesiredPeers::Specified(specified_peers))
    )
}

#[cfg(test)]
mod tests {
    use std::net::{Ipv4Addr};
    use std::io::{Write};

    use bip_util::bt::{InfoHash, PeerId};
    use bip_util::convert::{self};
    use byteorder::{WriteBytesExt, BigEndian};
    use nom::{IResult};
    
    use contact::{CompactPeers, CompactPeersV4, CompactPeersV6};
    use option::{AnnounceOptions};
    use super::{SourceIP, AnnounceEvent, ClientState, AnnounceRequest, DesiredPeers, AnnounceResponse};
    
    #[test]
    fn positive_write_request() {
        let mut received = Vec::new();
        
        let info_hash = [3, 4, 2, 3, 4, 3, 1, 6, 7, 56, 3, 234, 2, 3, 4, 3, 5, 6, 7, 8];
        let peer_id = [4, 2, 123, 23, 34, 5, 56, 2, 3, 4, 45, 6, 7, 8, 5, 6, 4, 56, 34, 42];
        let (downloaded, left, uploaded) = (123908, 12309123, 123123);
        let state = ClientState::new(downloaded, left, uploaded, AnnounceEvent::None);
        let ip = Ipv4Addr::new(127, 0, 0, 1);
        let key = 234234;
        let num_want = 34;
        let port = 6969;
        let options = AnnounceOptions::new();
        let request = AnnounceRequest::new(info_hash.into(), peer_id.into(), state, SourceIP::ExplicitV4(ip),
            key, DesiredPeers::Specified(num_want), port, options.clone());
            
        request.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_all(&info_hash).unwrap();
        expected.write_all(&peer_id).unwrap();
        expected.write_i64::<BigEndian>(downloaded).unwrap();
        expected.write_i64::<BigEndian>(left).unwrap();
        expected.write_i64::<BigEndian>(uploaded).unwrap();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_NONE_EVENT).unwrap();
        expected.write_all(&convert::ipv4_to_bytes_be(ip)).unwrap();
        expected.write_u32::<BigEndian>(key).unwrap();
        expected.write_i32::<BigEndian>(num_want).unwrap();
        expected.write_u16::<BigEndian>(port).unwrap();
        options.write_bytes(&mut expected).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_response() {
        let mut received = Vec::new();
        
        let (interval, leechers, seeders) = (213123, 3423423, 2342343);
        let mut peers = CompactPeersV4::new();
        peers.insert("127.0.0.1:2342".parse().unwrap());
        peers.insert("127.0.0.2:0".parse().unwrap());
        
        let response = AnnounceResponse::new(interval, leechers, seeders, CompactPeers::V4(peers.clone()));
        
        response.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(interval).unwrap();
        expected.write_i32::<BigEndian>(leechers).unwrap();
        expected.write_i32::<BigEndian>(seeders).unwrap();
        peers.write_bytes(&mut expected).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_state() {
        let mut received = Vec::new();
        
        let (downloaded, left, uploaded) = (123908, 12309123, 123123);
        let state = ClientState::new(downloaded, left, uploaded, AnnounceEvent::None);
        state.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i64::<BigEndian>(downloaded).unwrap();
        expected.write_i64::<BigEndian>(left).unwrap();
        expected.write_i64::<BigEndian>(uploaded).unwrap();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_NONE_EVENT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_none_event() {
        let mut received = Vec::new();
        
        let none_event = AnnounceEvent::None;
        none_event.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_NONE_EVENT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_completed_event() {
        let mut received = Vec::new();
        
        let none_event = AnnounceEvent::Completed;
        none_event.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_COMPLETED_EVENT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_started_event() {
        let mut received = Vec::new();
        
        let none_event = AnnounceEvent::Started;
        none_event.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_STARTED_EVENT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_stopped_event() {
        let mut received = Vec::new();
        
        let none_event = AnnounceEvent::Stopped;
        none_event.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(super::ANNOUNCE_STOPPED_EVENT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_source_ipv4_implied() {
        let mut received = Vec::new();
        
        let implied_ip = SourceIP::ImpliedV4;
        implied_ip.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_all(&super::IMPLIED_IPV4_ID).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_source_ipv6_implied() {
        let mut received = Vec::new();
        
        let implied_ip = SourceIP::ImpliedV6;
        implied_ip.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_all(&super::IMPLIED_IPV6_ID).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    
    #[test]
    fn positive_write_source_ipv4_explicit() {
        let mut received = Vec::new();
        
        let ip = Ipv4Addr::new(127, 0, 0, 1);
        let explicit_ip = SourceIP::ExplicitV4(ip);
        explicit_ip.write_bytes(&mut received).unwrap();
        
        let expected = convert::ipv4_to_bytes_be(ip);
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_source_ipv6_explicit() {
        let mut received = Vec::new();
        
        let ip = "ADBB:234A:55BD:FF34:3D3A:FFFF:234A:55BD".parse().unwrap();
        let explicit_ip = SourceIP::ExplicitV6(ip);
        explicit_ip.write_bytes(&mut received).unwrap();
        
        let expected = convert::ipv6_to_bytes_be(ip);
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_desired_peers_default() {
        let mut received = Vec::new();
        
        let desired_peers = DesiredPeers::Default;
        desired_peers.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(super::DEFAULT_NUM_WANT).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_write_desired_peers_specified() {
        let mut received = Vec::new();
        
        let desired_peers = DesiredPeers::Specified(500);
        desired_peers.write_bytes(&mut received).unwrap();
        
        let mut expected = Vec::new();
        expected.write_i32::<BigEndian>(500).unwrap();
        
        assert_eq!(&received[..], &expected[..]);
    }
    
    #[test]
    fn positive_parse_request_empty_options() {
        let info_hash = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1];
        let peer_id   = [2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3];
        
        let (downloaded, left, uploaded) = (456789, 283465, 200000);
        let state = ClientState::new(downloaded, left, uploaded, AnnounceEvent::Completed);
        
        let ip = SourceIP::ImpliedV4;
        let (key, num_want, port) = (255123, -102340, 1515);
        
        let mut bytes = Vec::new();
        bytes.write_all(&info_hash[..]).unwrap();
        bytes.write_all(&peer_id[..]).unwrap();
        bytes.write_i64::<BigEndian>(downloaded).unwrap();
        bytes.write_i64::<BigEndian>(left).unwrap();
        bytes.write_i64::<BigEndian>(uploaded).unwrap();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_COMPLETED_EVENT).unwrap();
        bytes.write_all(&super::IMPLIED_IPV4_ID).unwrap();
        bytes.write_u32::<BigEndian>(key).unwrap();
        bytes.write_i32::<BigEndian>(num_want).unwrap();
        bytes.write_u16::<BigEndian>(port).unwrap();
        
        let received = match AnnounceRequest::from_bytes_v4(&bytes) {
            IResult::Done(_, rec) => rec,
            _                     => panic!("AnnounceRequest Parsing Failed...")
        };
        
        assert_eq!(received.info_hash(), InfoHash::from(info_hash));
        assert_eq!(received.peer_id(), PeerId::from(peer_id));
        assert_eq!(received.state(), state);
        assert_eq!(received.source_ip(), ip);
        assert_eq!(received.key(), key);
        assert_eq!(received.num_want(), DesiredPeers::Specified(num_want));
        assert_eq!(received.port(), port);
    }
    
    #[test]
    fn negative_parse_request_missing_key() {
        let info_hash = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1];
        let peer_id   = [2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3];
        
        let (downloaded, left, uploaded) = (456789, 283465, 200000);
        
        let (_, num_want, port) = (255123, -102340, 1515);
        
        let mut bytes = Vec::new();
        bytes.write_all(&info_hash[..]).unwrap();
        bytes.write_all(&peer_id[..]).unwrap();
        bytes.write_i64::<BigEndian>(downloaded).unwrap();
        bytes.write_i64::<BigEndian>(left).unwrap();
        bytes.write_i64::<BigEndian>(uploaded).unwrap();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_COMPLETED_EVENT).unwrap();
        bytes.write_all(&super::IMPLIED_IPV4_ID).unwrap();
        bytes.write_i32::<BigEndian>(num_want).unwrap();
        bytes.write_u16::<BigEndian>(port).unwrap();
        
        let received = AnnounceRequest::from_bytes_v4(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn positive_parse_response_empty_peers() {
        let (interval, leechers, seeders) = (34, 234, 0);
    
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(interval).unwrap();
        bytes.write_i32::<BigEndian>(leechers).unwrap();
        bytes.write_i32::<BigEndian>(seeders).unwrap();
        
        let received_v4 = AnnounceResponse::from_bytes_v4(&bytes);
        let received_v6 = AnnounceResponse::from_bytes_v6(&bytes);
        
        let expected_v4 = AnnounceResponse::new(interval, leechers, seeders,
            CompactPeers::V4(CompactPeersV4::new()));
        let expected_v6 = AnnounceResponse::new(interval, leechers, seeders,
            CompactPeers::V6(CompactPeersV6::new()));
    
        assert_eq!(received_v4, IResult::Done(&b""[..], expected_v4));
        assert_eq!(received_v6, IResult::Done(&b""[..], expected_v6));
    }
    
    #[test]
    fn positive_parse_response_many_peers() {
        let (interval, leechers, seeders) = (34, 234, 0);
    
        let mut peers_v4 = CompactPeersV4::new();
        peers_v4.insert("127.0.0.1:3412".parse().unwrap());
        peers_v4.insert("10.0.0.1:2323".parse().unwrap());
        
        let mut peers_v6 = CompactPeersV6::new();
        peers_v6.insert("[ADBB:234A:55BD:FF34:3D3A:FFFF:234A:55BD]:3432".parse().unwrap());
        peers_v6.insert("[ADBB:234A::FF34:3D3A:FFFF:234A:55BD]:2222".parse().unwrap());
     
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(interval).unwrap();
        bytes.write_i32::<BigEndian>(leechers).unwrap();
        bytes.write_i32::<BigEndian>(seeders).unwrap();
        
        let mut bytes_v4 = bytes.clone();
        peers_v4.write_bytes(&mut bytes_v4).unwrap();
        
        let mut bytes_v6 = bytes.clone();
        peers_v6.write_bytes(&mut bytes_v6).unwrap();
        
        let received_v4 = AnnounceResponse::from_bytes_v4(&bytes_v4);
        let received_v6 = AnnounceResponse::from_bytes_v6(&bytes_v6);
        
        let expected_v4 = AnnounceResponse::new(interval, leechers, seeders,
            CompactPeers::V4(peers_v4));
        let expected_v6 = AnnounceResponse::new(interval, leechers, seeders,
            CompactPeers::V6(peers_v6));
    
        assert_eq!(received_v4, IResult::Done(&b""[..], expected_v4));
        assert_eq!(received_v6, IResult::Done(&b""[..], expected_v6));
    }
    
    #[test]
    fn positive_parse_state() {
        let (downloaded, left, uploaded) = (202340, 52340, 5043);
        
        let mut bytes = Vec::new();
        bytes.write_i64::<BigEndian>(downloaded).unwrap();
        bytes.write_i64::<BigEndian>(left).unwrap();
        bytes.write_i64::<BigEndian>(uploaded).unwrap();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_NONE_EVENT).unwrap();
        
        let received = ClientState::from_bytes(&bytes);
        let expected = ClientState::new(downloaded, left, uploaded, AnnounceEvent::None);
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn negative_parse_incomplete_state() {
        let (downloaded, left, uploaded) = (202340, 52340, 5043);
        
        let mut bytes = Vec::new();
        bytes.write_i64::<BigEndian>(downloaded).unwrap();
        bytes.write_i64::<BigEndian>(left).unwrap();
        bytes.write_i64::<BigEndian>(uploaded).unwrap();
        
        let received = ClientState::from_bytes(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn positive_parse_none_event() {
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_NONE_EVENT).unwrap();
        
        let received = AnnounceEvent::from_bytes(&bytes);
        let expected = AnnounceEvent::None;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_completed_event() {
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_COMPLETED_EVENT).unwrap();
        
        let received = AnnounceEvent::from_bytes(&bytes);
        let expected = AnnounceEvent::Completed;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_started_event() {
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_STARTED_EVENT).unwrap();
        
        let received = AnnounceEvent::from_bytes(&bytes);
        let expected = AnnounceEvent::Started;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn negative_parse_no_event() {
        let bytes = [1, 2, 3, 4];
        
        let received = AnnounceEvent::from_bytes(&bytes);
        
        assert!(received.is_err());
    }
    
    #[test]
    fn positive_parse_stopped_event() {
        let mut bytes = Vec::new();
        bytes.write_i32::<BigEndian>(super::ANNOUNCE_STOPPED_EVENT).unwrap();
        
        let received = AnnounceEvent::from_bytes(&bytes);
        let expected = AnnounceEvent::Stopped;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_implied_v4_source() {
        let mut bytes = Vec::new();
        bytes.write_all(&super::IMPLIED_IPV4_ID).unwrap();
        
        let received = SourceIP::from_bytes_v4(&bytes);
        let expected = SourceIP::ImpliedV4;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_explicit_v4_source() {
        let bytes = [127, 0, 0, 1];
        
        let received = SourceIP::from_bytes_v4(&bytes);
        let expected = SourceIP::ExplicitV4(Ipv4Addr::new(127, 0, 0, 1));
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_implied_v6_source() {
        let mut bytes = Vec::new();
        bytes.write_all(&super::IMPLIED_IPV6_ID).unwrap();
        
        let received = SourceIP::from_bytes_v6(&bytes);
        let expected = SourceIP::ImpliedV6;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_explicit_v6_source() {
        let ip = "ADBB:234A:55BD:FF34:3D3A:FFFF:234A:55BD".parse().unwrap();
        let bytes = convert::ipv6_to_bytes_be(ip);
        
        let received = SourceIP::from_bytes_v6(&bytes);
        let expected = SourceIP::ExplicitV6(ip);
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    
    #[test]
    fn negative_parse_incomplete_v4_source() {
        let bytes = [0, 0];
        
        let received = SourceIP::from_bytes_v4(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn negative_parse_incomplete_v6_source() {
        let bytes = [0, 0, 0, 0];
        
        let received = SourceIP::from_bytes_v6(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn negative_parse_empty_v4_source() {
        let bytes = [];
        
        let received = SourceIP::from_bytes_v4(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn negative_parse_empty_v6_source() {
        let bytes = [];
        
        let received = SourceIP::from_bytes_v6(&bytes);
        
        assert!(received.is_incomplete());
    }
    
    #[test]
    fn positive_parse_desired_peers_default() {
        let default_bytes = convert::four_bytes_to_array(-1i32 as u32);
        
        let received = DesiredPeers::from_bytes(&default_bytes);
        let expected = DesiredPeers::Default;
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
    
    #[test]
    fn positive_parse_desired_peers_specified() {
        let specified_bytes = convert::four_bytes_to_array(50);
        
        let received = DesiredPeers::from_bytes(&specified_bytes);
        let expected = DesiredPeers::Specified(50);
        
        assert_eq!(received, IResult::Done(&b""[..], expected));
    }
}