use crate::{
    app::session::{SessionToken, SessionFilter},
    util::pack::{pack_u16, pack_u32, unpack_u8, unpack_u16, unpack_u32},
};

use super::Packet;

#[derive(Clone)]
pub struct PacketSessionList {
    pub filter:SessionFilter,

    //pub page:u16,
    //pub game_state:u8,
    //pub is_player:bool,
    //pub is_live:bool,
}
impl PacketSessionList {
    pub fn new() -> Self
    {
        Self {
            filter:SessionFilter::new(),

            //page:0,
            //game_state:0,
            //is_player:false,
            //is_live:false,
        }
    }
}
impl Packet for PacketSessionList {
    type Data = Self;

    fn decode(data:&Vec<u8>, index:&mut usize) -> Result<Self::Data, ()>
    {
        let mut result = Self::new();
        
        if data.len() - *index > 6 {
            result.filter.start = unpack_u32(data, index) as usize;
            result.filter.count = unpack_u32(data, index) as usize;

            let filter_length = unpack_u16(data, index);
            for _ in 0..filter_length {
                let code = unpack_u8(data, index);
                match code {
                    0x00 => { result.filter.is_complete = Some(unpack_u8(data, index) != 0); }
                    0x01 => { result.filter.is_live = Some(unpack_u8(data, index) != 0); }
                    0x02 => { result.filter.is_player = Some(unpack_u8(data, index) != 0); }
                    0x10 => {
                        let handle_length = unpack_u8(data, index) as usize;
                        if data.len() - *index >= handle_length {
                            if let Ok(handle) = String::from_utf8(data[*index..*index+handle_length].to_vec()) {
                                if result.filter.player[0].is_none() {
                                    result.filter.player[0] = Some(handle);
                                } else if result.filter.player[1].is_none() {
                                    result.filter.player[1] = Some(handle);
                                }
                            }
                        }
                    }
                    _ => { }
                }
            }

            Ok(result)
        } else {
            Err(())
        }
    }
}


#[derive(Clone)]
pub struct PacketSessionListResponseRecord {
    pub token:SessionToken,
    pub handles:[String; 2],
    pub turn:u16,
    pub last_move:u32,
    pub viewers:u32,
    pub player:u8,
    pub is_turn:bool,
    pub is_complete:u8,
}
impl PacketSessionListResponseRecord {
    pub fn encode(&self) -> Vec<u8>
    {
        let mut output = self.token.to_vec();

        let mut flags = 0u32;
        flags |= self.player as u32;
        flags |= (self.is_turn as u32) << 2;
        flags |= (self.is_complete as u32) << 3;

        // Flags
        output.append(&mut pack_u32(flags));

        // Dawn handle
        let mut bytes = self.handles[0].as_bytes().to_vec();
        output.append(&mut pack_u16(bytes.len() as u16));
        if bytes.len() > 0 { output.append(&mut bytes); }

        // Dusk handle
        let mut bytes = self.handles[1].as_bytes().to_vec();
        output.append(&mut pack_u16(bytes.len() as u16));
        if bytes.len() > 0 { output.append(&mut bytes); }

        // Turn number
        output.append(&mut pack_u16(self.turn));

        // Last move
        output.append(&mut pack_u32(self.last_move));

        // Spectator count
        output.append(&mut pack_u32(self.viewers));

        // User is player
        //chunk.append(&mut vec![record.player as u8]);

        output
    }
}

#[derive(Clone)]
pub struct PacketSessionListResponse {
    pub records:Vec<PacketSessionListResponseRecord>,
}
impl PacketSessionListResponse {
    pub fn new() -> Self
    {
        Self {
            records:Vec::new(),
        }
    }
}
impl Packet for PacketSessionListResponse {
    type Data = Self;

    fn encode(&self) -> Vec<u8>
    {
        let mut result = pack_u16(self.records.len() as u16);
        for record in &self.records {
            result.append(&mut record.encode());
        }
        result
    }
}