extern crate serde_json;
use crate::parser;
use rayon::prelude::*;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use std::thread::{spawn, JoinHandle};
use std::thread;
use std::sync::mpsc::{channel, Receiver};
use serde_json::json;

impl Serialize for parser::QryData {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("parser::QryData", 11)?;
        state.serialize_field("time", &self.time)?;
        state.serialize_field("ether_header.ether_dhost", &self.ether_header.ether_dhost.to_hex_string())?;
        state.serialize_field("ether_header.ether_shost", &self.ether_header.ether_shost.to_hex_string())?;
        state.serialize_field("ether_header.ether_type", &self.ether_header.ether_type)?;
        state.serialize_field("ipv4_header", &self.ipv4_header)?;
        state.serialize_field("ipv6_header", &self.ipv6_header)?;
        state.serialize_field("tcp_header", &self.tcp_header)?;
        state.serialize_field("udp_header", &self.udp_header)?;
        state.serialize_field("arp_header", &self.arp_header)?;
        state.serialize_field("data", &self.data)?;
        state.serialize_field("reg_res", &self.reg_res)?;
        state.end()
    }
}

pub fn serialize_packets(v: Vec<parser::QryData>) -> Vec<serde_json::Value> {

    /* rayon parallelized */
    // TODO: Benchmark. As far as I tested, this reaps no benefit.
    let packets_serialized = v.par_iter().map(|x| serde_json::to_value(x).unwrap()).collect();
     //let packets_serialized: Vec<serde_json::Value> = v.par_iter().map(|x| json!(x)).collect();

    packets_serialized
}


// This is way faster than serialize_packets() but I can not figure out how to properly select parts from the resulting json structure as an sql query 
#[allow(dead_code)]
pub fn serialize_packets_as_string(v: Vec<parser::QryData>) -> Vec<serde_json::Value> {
    let mut packets_serialized: Vec<serde_json::Value> = Vec::with_capacity(v.len() * 2);
     for packet in v.iter() {
         packets_serialized.push(serde_json::Value::String(serde_json::to_string(&packet).unwrap()));
     }

    packets_serialized
}

#[allow(dead_code)]
fn smallest_prime_divisor(remainder: usize ) -> usize {
    let smallest_divisor: usize = (2..(remainder/2)).into_par_iter().find_first(|x| remainder % x == 0).unwrap();
    smallest_divisor
}
#[allow(dead_code)]
//pub fn start_serialize_packets_thread(parsed_data: Receiver<parser::QryData>) -> (Receiver<serde_json::Value>, JoinHandle<()>) {
pub fn start_serialize_packets_thread(parsed_data: Receiver<parser::QryData>) -> (Receiver<serde_json::Value>, JoinHandle<()>) {
        let (sender, receiver) = channel();
        let handle = spawn ( move || { 
        for data in parsed_data { 
        //serde_json::Value::String(serde_json::to_string(&packet).unwrap())
        if sender.send(serde_json::to_value(data).unwrap()).is_err() {
            break;
        }
        } 
        });
       
        (receiver, handle)
}

#[allow(dead_code)]
pub fn start_collect_serialized( serialized_data: Receiver<serde_json::Value> ) -> Vec<serde_json::Value> {
    //let (sender, receiver) = channel();
    let mut packets_serialized:Vec<serde_json::Value> = Vec::new();
    for data in serialized_data {
        packets_serialized.push(data);
    }

    packets_serialized
    

}

pub fn start_serialize_vec_thread(parsed_data: Receiver<Vec<parser::QryData>>) -> Receiver<serde_json::Value> {
        let (sender, receiver) = channel();
    for vec in parsed_data { 
        for packet in vec {
          let sender = sender.clone();
          let handle = spawn ( move || { 
             //sender.send(start_serialize_packets_thread(packet));       
                sender.send(json!(packet))
              //sender.send( serde_json::to_value(packet).unwrap())
        //serde_json::Value::String(serde_json::to_string(&packet).unwrap())
        //if sender.send(serde_json::to_value(data).unwrap()).is_err() {
        //    break;
        }
        );}
        //});
       }
      receiver
}