elseware/src/ship/packet/handler/quest.rs

use std::io::{Cursor, Read, Seek, SeekFrom};
use libpso::packet::ship::*;
use crate::common::serverstate::ClientId;
use crate::ship::ship::{SendShipPacket, ShipError, Clients, Rooms};
use crate::ship::location::{ClientLocation, ClientLocationError};
use crate::ship::packet::builder::quest;
use libpso::util::array_to_utf8;

// TOOD: enum
enum QuestFileType {
    Bin,
    Dat
}

fn parse_filename(filename_bytes: &[u8; 16]) -> Result<(u16, u16, QuestFileType), ShipError> {
    let filename = array_to_utf8(*filename_bytes).map_err(|_| ShipError::InvalidQuestFilename("NOT UTF8".to_string()))?;
    let (filename, suffix) = {
        let mut s = filename.splitn(2, '.');
        (s.next().ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?,
         s.next().ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?)
    };

    let datatype = match suffix {
        "bin" => QuestFileType::Bin,
        "dat" => QuestFileType::Dat,
        _ => return Err(ShipError::InvalidQuestFilename(filename.to_owned()))
    };

    let (category, quest) = {
        let mut s = filename.splitn(2, '-');
        (s.next().and_then(|k| k.parse().ok()).ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?,
         s.next().and_then(|k| k.parse().ok()).ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?)
    };

    Ok((category, quest, datatype))
}


pub async fn send_quest_category_list(id: ClientId, rql: &RequestQuestList, client_location: &ClientLocation, rooms: &mut Rooms) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;
    let qcl = quest::quest_category_list(&room.quests[rql.flag.clamp(0, (room.quests.len() - 1) as u32) as usize]);
    room.set_quest_group(rql.flag as usize);
    Ok(Box::new(vec![(id, SendShipPacket::QuestCategoryList(qcl))].into_iter()))
}

pub async fn select_quest_category(id: ClientId, menuselect: &MenuSelect, client_location: &ClientLocation, rooms: &mut Rooms) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;
    let (_, category_quests) = room.quests[room.quest_group.value()].iter()
        .nth(menuselect.item as usize)
        .ok_or(ShipError::InvalidQuestCategory(menuselect.item))?;

    let ql = quest::quest_list(menuselect.item, category_quests);
    for q in ql.quests.clone() {
        println!("name: {:?} quest_id: {}", q.name, q.quest_id);
    }
    Ok(Box::new(vec![(id, SendShipPacket::QuestOptionList(ql))].into_iter()))
}


pub async fn quest_detail(id: ClientId, questdetailrequest: &QuestDetailRequest, client_location: &ClientLocation, rooms: &mut Rooms) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;
    let (_, category_quests) = room.quests[room.quest_group.value()].iter()
        .nth(questdetailrequest.category as usize)
        .ok_or(ShipError::InvalidQuestCategory(questdetailrequest.category as u32))?;

    let quest = category_quests.iter()
        .find(|q| {
            q.id == questdetailrequest.quest as u16
        }).ok_or(ShipError::InvalidQuest(questdetailrequest.quest as u32))?;

    let qd = quest::quest_detail(quest);
    
    Ok(Box::new(vec![(id, SendShipPacket::QuestDetail(qd))].into_iter()))
}

pub async fn player_chose_quest(id: ClientId, questmenuselect: &QuestMenuSelect, clients: &mut Clients, client_location: &ClientLocation, rooms: &mut Rooms)
                  -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;                
    let (_, category_quests) = room.quests[room.quest_group.value()].iter()
        .nth(questmenuselect.category as usize)
        .ok_or(ShipError::InvalidQuestCategory(questmenuselect.category as u32))?;

    let quest = category_quests.iter()
        .find(|q| {
            q.id == questmenuselect.quest as u16
        }).ok_or(ShipError::InvalidQuest(questmenuselect.quest as u32))?;

    room.maps.set_quest_data(quest.enemies.clone(), quest.objects.clone(), &room.rare_monster_table);
    room.map_areas = quest.map_areas.clone();

    let bin = quest::quest_header(questmenuselect, &quest.bin_blob, "bin");
    let dat = quest::quest_header(questmenuselect, &quest.dat_blob, "dat");

    let area_clients = client_location.get_all_clients_by_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    area_clients.iter().for_each(|c| {
        if let Some(client) = clients.get_mut(&c.client) {
            client.done_loading_quest = false;
        }
    });
    Ok(Box::new(area_clients.into_iter().flat_map(move |c| {
        vec![(c.client, SendShipPacket::QuestHeader(bin.clone())), (c.client, SendShipPacket::QuestHeader(dat.clone()))]
    })))
}

pub async fn quest_file_request(id: ClientId, quest_file_request: &QuestFileRequest, client_location: &ClientLocation, rooms: &mut Rooms) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;

    let (category_id, quest_id, datatype) = parse_filename(&quest_file_request.filename)?;
    let (_, category_quests) = room.quests[room.quest_group.value()].iter()
        .nth(category_id as usize)
        .ok_or(ShipError::InvalidQuestCategory(category_id as u32))?;

    let quest = category_quests.iter()
        .find(|q| {
            q.id == quest_id as u16
        }).ok_or(ShipError::InvalidQuest(quest_id as u32))?;

    let blob = match datatype {
        QuestFileType::Bin => &quest.bin_blob,
        QuestFileType::Dat => &quest.dat_blob,
    };
    let mut blob_cursor = Cursor::new(blob);

    let mut subblob = [0u8; 0x400];
    let blob_length = blob_cursor.read(&mut subblob)?;
    let qc = quest::quest_chunk(0, quest_file_request.filename, subblob, blob_length);
    
    Ok(Box::new(vec![(id, SendShipPacket::QuestChunk(qc))].into_iter()))
}

pub async fn quest_chunk_ack(id: ClientId, quest_chunk_ack: &QuestChunkAck, client_location: &ClientLocation, rooms: &mut Rooms) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let room_id = client_location.get_room(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?.as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;

    let (category_id, quest_id, datatype) = parse_filename(&quest_chunk_ack.filename)?;
    let (_, category_quests) = room.quests[room.quest_group.value()].iter()
        .nth(category_id as usize)
        .ok_or(ShipError::InvalidQuestCategory(category_id as u32))?;

    let quest = category_quests.iter()
        .find(|q| {
            q.id == quest_id
        }).ok_or(ShipError::InvalidQuest(quest_id as u32))?;

    let blob = match datatype {
        QuestFileType::Bin => &quest.bin_blob,
        QuestFileType::Dat => &quest.dat_blob,
    };

    let mut blob_cursor = Cursor::new(blob);
    blob_cursor.seek(SeekFrom::Start((quest_chunk_ack.chunk_num as u64 + 1) * 0x400))?;
    let mut subblob = [0u8; 0x400];
    let blob_length = blob_cursor.read(&mut subblob)?;
    if blob_length == 0 {
        return Ok(Box::new(None.into_iter()));
    }
    let qc = quest::quest_chunk(quest_chunk_ack.chunk_num + 1, quest_chunk_ack.filename, subblob, blob_length);
    
    Ok(Box::new(vec![(id, SendShipPacket::QuestChunk(qc))].into_iter()))
}

pub async fn done_loading_quest(id: ClientId, clients: &mut Clients, client_location: &ClientLocation)
                                -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    client.done_loading_quest = true;
    let area_clients = client_location.get_all_clients_by_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
    let all_loaded = area_clients.iter().all(|c| {
        clients.get(&c.client)
            .map(|client| {
                client.done_loading_quest
            })
            .unwrap_or(false)
    });

    if all_loaded {
        Ok(Box::new(area_clients.into_iter().map(|c| {
            (c.client, SendShipPacket::DoneLoadingQuest(DoneLoadingQuest {}))
        })))
    }
    else {
        Ok(Box::new(None.into_iter()))
    }
}