extern crate pnet;
extern crate rand;

// use getopts::Options;
use std::env;
use std::net::{IpAddr, Ipv4Addr};
use std::str::FromStr;
use pnet::transport::TransportChannelType::Layer4;
use pnet::transport::TransportProtocol::Ipv4;
use pnet::transport::{transport_channel, ipv4_packet_iter};
use pnet::packet::icmp::{MutableIcmpPacket, IcmpTypes, echo_reply, echo_request, checksum};
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::MutablePacket;

fn create_ping_packet<'a>(empty_packet: &'a mut echo_request::MutableEchoRequestPacket, id: u16, seq_num: u16) {
    empty_packet.set_icmp_type(IcmpTypes::EchoRequest);
    empty_packet.set_icmp_code(echo_request::IcmpCodes::NoCode);
    empty_packet.set_identifier(id);
    empty_packet.set_sequence_number(seq_num);
    empty_packet.set_payload(b"Ring ring");
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let host = args[args.len() - 1].clone();
    let ip_address = IpAddr::V4(Ipv4Addr::from_str(&host).unwrap());

    let icmp_protocol = Layer4(Ipv4(IpNextHeaderProtocols::Icmp));
    let buffer_size = 4096;
    let (mut t_sender, mut t_receiver) = match transport_channel(buffer_size, icmp_protocol) {
        Ok((t_sender, t_receiver)) => (t_sender, t_receiver),
        Err(err) => panic!("{:?}", err),
    };

    let id = rand::random::<u16>();
    let mut seq_num = 0;
    let mut empty_packet_contents : [u8; 32] = Default::default();
    let mut empty_packet = echo_request::MutableEchoRequestPacket::new(&mut empty_packet_contents).unwrap();

    loop {
        create_ping_packet(&mut empty_packet, id, seq_num);
        let mut raw_ping_packet = empty_packet.packet_mut();

        let mut icmp_packet = MutableIcmpPacket::new(&mut raw_ping_packet).unwrap();
        let checksum = checksum(&icmp_packet.to_immutable());
        icmp_packet.set_checksum(checksum);

        match t_sender.send_to(icmp_packet, ip_address) {
            Ok(_) => println!("Sent"),
            Err(e) => panic!("{}", e),
        }
        let mut iter = ipv4_packet_iter(&mut t_receiver);
        match iter.next() {
            Ok((packet, _)) => println!("Received"),
            Err(e) => println!("{}", e),
        }
        seq_num += 1;
    }
}