use super::{
    get_player_item_or_fail, user_error, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
};
use crate::{
    models::item::{Item, ItemSpecialData},
    static_content::{
        dynzone,
        room::{self, Direction, GridCoords},
    },
};
use ansi::{ansi, flow_around};
use async_trait::async_trait;
use std::sync::Arc;

pub fn render_map(room: &room::Room, width: usize, height: usize) -> String {
    let mut buf = String::new();
    let my_loc = &room.grid_coords;
    let min_x = my_loc.x - (width as i64) / 2;
    let max_x = min_x + (width as i64);
    let min_y = my_loc.y - (height as i64) / 2;
    let max_y = min_y + (height as i64);
    for y in min_y..max_y {
        for x in min_x..max_x {
            if my_loc.x == x && my_loc.y == y {
                buf.push_str(ansi!("<bgblue><red>()<reset>"))
            } else {
                buf.push_str(
                    &room::room_map_by_zloc()
                        .get(&(&room.zone, &room::GridCoords { x, y, z: my_loc.z }))
                        .map(|r| {
                            if room.zone == r.zone {
                                r.short.as_str()
                            } else {
                                r.secondary_zones
                                    .iter()
                                    .find(|sz| sz.zone == room.zone)
                                    .map(|sz| sz.short.as_str())
                                    .expect("Secondary zone missing")
                            }
                        })
                        .unwrap_or("  "),
                );
            }
        }
        buf.push('\n');
    }
    buf
}

pub fn render_map_dyn(
    dynzone: &dynzone::Dynzone,
    dynroom: &dynzone::Dynroom,
    width: usize,
    height: usize,
) -> String {
    let mut buf = String::new();
    let my_loc = &dynroom.grid_coords;
    let min_x = my_loc.x - (width as i64) / 2;
    let max_x = min_x + (width as i64);
    let min_y = my_loc.y - (height as i64) / 2;
    let max_y = min_y + (height as i64);

    let main_exit: Option<GridCoords> = dynzone
        .dyn_rooms
        .iter()
        .flat_map(|(_, dr)| {
            dr.exits
                .iter()
                .filter(|ex| match ex.target {
                    dynzone::ExitTarget::ExitZone => true,
                    _ => false,
                })
                .map(|ex| dr.grid_coords.apply(&ex.direction))
        })
        .next();

    for y in min_y..max_y {
        for x in min_x..max_x {
            if my_loc.x == x && my_loc.y == y {
                buf.push_str(ansi!("<bgblue><red>()<reset>"))
            } else {
                buf.push_str(
                    dynzone
                        .dyn_rooms
                        .iter()
                        .find(|(_, dr)| {
                            dr.grid_coords.x == x
                                && dr.grid_coords.y == y
                                && dr.grid_coords.z == my_loc.z
                        })
                        .map(|(_, r)| r.short)
                        .or_else(|| {
                            main_exit.as_ref().and_then(|ex_pos| {
                                if ex_pos.x == x && ex_pos.y == y && ex_pos.z == my_loc.z {
                                    Some("<<")
                                } else {
                                    None
                                }
                            })
                        })
                        .unwrap_or("  "),
                );
            }
        }
        buf.push('\n');
    }
    buf
}

pub fn render_lmap(
    room: &room::Room,
    width: usize,
    height: usize,
    captions_needed: &mut Vec<(usize, &'static str, &'static str)>,
) -> String {
    let mut buf = String::new();
    let my_loc = &room.grid_coords;
    let min_x = my_loc.x - (width as i64) / 2;
    let max_x = min_x + (width as i64);
    let min_y = my_loc.y - (height as i64) / 2;
    let max_y = min_y + (height as i64);
    for y in min_y..max_y {
        for x in min_x..max_x {
            let coord = room::GridCoords { x, y, z: my_loc.z };
            let coord_room = room::room_map_by_zloc().get(&(&room.zone, &coord));
            if my_loc.x == x && my_loc.y == y {
                buf.push_str(ansi!("<bgblue><red> () <reset>"))
            } else {
                let code_capt_opt = coord_room.map(|r| {
                    if room.zone == r.zone {
                        (
                            r.short.as_str(),
                            if r.should_caption {
                                Some((
                                    r.name.as_str(),
                                    ((my_loc.x as i64 - r.grid_coords.x).abs()
                                        + (my_loc.y as i64 - r.grid_coords.y).abs())
                                        as usize,
                                ))
                            } else {
                                None
                            },
                        )
                    } else {
                        r.secondary_zones
                            .iter()
                            .find(|sz| sz.zone == room.zone)
                            .map(|sz| {
                                (
                                    sz.short.as_str(),
                                    sz.caption.as_ref().map(|c| {
                                        (
                                            c.as_str(),
                                            ((my_loc.x as i64 - r.grid_coords.x).abs()
                                                + (my_loc.y as i64 - r.grid_coords.y).abs())
                                                as usize,
                                        )
                                    }),
                                )
                            })
                            .expect("Secondary zone missing")
                    }
                });
                match code_capt_opt {
                    None => buf.push_str("    "),
                    Some((code, capt_opt)) => {
                        if let Some((capt, closeness)) = capt_opt {
                            captions_needed.push((closeness, &code, &capt));
                        }
                        buf.push('[');
                        buf.push_str(&code);
                        buf.push(']');
                    }
                }
            }
            match coord_room.and_then(|r| r.exits.iter().find(|ex| ex.direction == Direction::EAST))
            {
                None => buf.push(' '),
                Some(_) => buf.push('-'),
            }
        }
        buf.push('\n');
        for x in min_x..max_x {
            let mut coord = room::GridCoords { x, y, z: my_loc.z };
            let coord_room = room::room_map_by_zloc().get(&(&room.zone, &coord));
            match coord_room
                .and_then(|r| r.exits.iter().find(|ex| ex.direction == Direction::SOUTH))
            {
                None => buf.push_str("    "),
                Some(_) => buf.push_str(" |  "),
            }
            let has_se = coord_room
                .and_then(|r| {
                    r.exits
                        .iter()
                        .find(|ex| ex.direction == Direction::SOUTHEAST)
                })
                .is_some();
            coord.x += 1;
            let coord_room_s = room::room_map_by_zloc().get(&(&room.zone, &coord));
            let has_sw = coord_room_s
                .and_then(|r| {
                    r.exits
                        .iter()
                        .find(|ex| ex.direction == Direction::SOUTHWEST)
                })
                .is_some();
            if has_se && has_sw {
                buf.push('X');
            } else if has_se {
                buf.push('\\');
            } else if has_sw {
                buf.push('/');
            } else {
                buf.push(' ');
            }
        }
        buf.push('\n');
    }
    captions_needed.sort_unstable_by(|a, b| a.0.cmp(&b.0));
    buf
}

pub fn render_lmap_dynroom<'l, 'm>(
    zone: &'l dynzone::Dynzone,
    room: &'l dynzone::Dynroom,
    width: usize,
    height: usize,
    captions_needed: &'m mut Vec<(usize, &'l str, &'l str)>,
    connectwhere: Option<&'l str>,
) -> String {
    let mut buf = String::new();
    let my_loc = &room.grid_coords;
    let min_x = my_loc.x - (width as i64) / 2;
    let max_x = min_x + (width as i64);
    let min_y = my_loc.y - (height as i64) / 2;
    let max_y = min_y + (height as i64);

    let main_exit_dat: Option<(GridCoords, Direction)> = zone
        .dyn_rooms
        .iter()
        .flat_map(|(_, dr)| {
            dr.exits
                .iter()
                .filter(|ex| match ex.target {
                    dynzone::ExitTarget::ExitZone => true,
                    _ => false,
                })
                .map(|ex| (dr.grid_coords.apply(&ex.direction), ex.direction.clone()))
        })
        .next();
    let main_exit = main_exit_dat.as_ref();

    for y in min_y..max_y {
        for x in min_x..max_x {
            let coord = room::GridCoords { x, y, z: my_loc.z };
            let coord_room: Option<&dynzone::Dynroom> = zone
                .dyn_rooms
                .iter()
                .find(|(_, dr)| {
                    dr.grid_coords.x == x && dr.grid_coords.y == y && dr.grid_coords.z == my_loc.z
                })
                .map(|(_, r)| r);
            if my_loc.x == x && my_loc.y == y {
                buf.push_str(ansi!("<bgblue><red> () <reset>"));
                if let Some(room) = coord_room {
                    if room.should_caption {
                        captions_needed.push((
                            (((my_loc.x as i64 - room.grid_coords.x).abs()
                                + (my_loc.y as i64 - room.grid_coords.y).abs())
                                as usize),
                            room.short,
                            room.name,
                        ));
                    }
                    match room.exits.iter().find(|ex| ex.direction == Direction::EAST) {
                        None => buf.push(' '),
                        Some(_) => buf.push('-'),
                    }
                }
            } else if let Some(room) = coord_room {
                if room.should_caption {
                    captions_needed.push((
                        (((my_loc.x as i64 - room.grid_coords.x).abs()
                            + (my_loc.y as i64 - room.grid_coords.y).abs())
                            as usize),
                        room.short,
                        room.name,
                    ));
                }
                buf.push('[');
                buf.push_str(room.short);
                buf.push(']');
                match room.exits.iter().find(|ex| ex.direction == Direction::EAST) {
                    None => buf.push(' '),
                    Some(_) => buf.push('-'),
                }
            } else if main_exit.map(|ex| &ex.0) == Some(&coord) {
                buf.push_str("[<<]");
                match main_exit {
                    Some((ex_coord, Direction::WEST)) => {
                        buf.push('-');
                        if let Some(connect) = connectwhere {
                            captions_needed.push((
                                ((my_loc.x as i64 - ex_coord.x).abs()
                                    + (my_loc.y as i64 - ex_coord.y).abs())
                                    as usize,
                                "<<",
                                connect,
                            ))
                        }
                    }
                    _ => buf.push(' '),
                }
            } else {
                buf.push_str("     ");
            }
        }
        buf.push('\n');
        for x in min_x..max_x {
            let mut coord = room::GridCoords { x, y, z: my_loc.z };
            let coord_room: Option<&'l dynzone::Dynroom> = zone
                .dyn_rooms
                .iter()
                .find(|(_, dr)| {
                    dr.grid_coords.x == x && dr.grid_coords.y == y && dr.grid_coords.z == my_loc.z
                })
                .map(|(_, r)| r);
            match coord_room
                .and_then(|r| r.exits.iter().find(|ex| ex.direction == Direction::SOUTH))
            {
                Some(_) => buf.push_str(" |  "),
                None if main_exit == Some(&(coord.clone(), Direction::NORTH)) => {
                    buf.push_str(" |  ")
                }
                None => buf.push_str("    "),
            }
            let has_se = coord_room
                .and_then(|r| {
                    r.exits
                        .iter()
                        .find(|ex| ex.direction == Direction::SOUTHEAST)
                })
                .is_some()
                || (main_exit == Some(&(coord.clone(), Direction::NORTHWEST)));
            coord.x += 1;
            let coord_room_s = zone
                .dyn_rooms
                .iter()
                .find(|(_, dr)| {
                    dr.grid_coords.x == coord.x
                        && dr.grid_coords.y == coord.y
                        && dr.grid_coords.z == my_loc.z
                })
                .map(|(_, r)| r);
            let has_sw = coord_room_s
                .and_then(|r| {
                    r.exits
                        .iter()
                        .find(|ex| ex.direction == Direction::SOUTHWEST)
                })
                .is_some()
                || (main_exit == Some(&(coord, Direction::NORTHEAST)));
            if has_se && has_sw {
                buf.push('X');
            } else if has_se {
                buf.push('\\');
            } else if has_sw {
                buf.push('/');
            } else {
                buf.push(' ');
            }
        }
        buf.push('\n');
    }
    captions_needed.sort_unstable_by(|a, b| a.0.cmp(&b.0));
    buf
}

pub fn caption_lmap<'l>(
    captions: &Vec<(usize, &'l str, &'l str)>,
    width: usize,
    height: usize,
) -> String {
    let mut buf = String::new();
    for room in captions.iter().take(height) {
        buf.push_str(&format!(
            ansi!("{}<bold>: {:.*}<reset>\n"),
            room.1, width, room.2
        ));
    }
    buf
}

#[async_trait]
trait MapType {
    async fn map_room(&self, ctx: &VerbContext<'_>, room: &room::Room) -> UResult<()>;
    async fn map_room_dyn<'a>(
        &self,
        ctx: &VerbContext<'_>,
        zone: &'a dynzone::Dynzone,
        room: &'a dynzone::Dynroom,
        zoneref: &str,
    ) -> UResult<()>;
}

pub struct LmapType;

#[async_trait]
impl MapType for LmapType {
    async fn map_room(&self, ctx: &VerbContext<'_>, room: &room::Room) -> UResult<()> {
        let mut captions: Vec<(usize, &'static str, &'static str)> = Vec::new();
        ctx.trans
            .queue_for_session(
                ctx.session,
                Some(&flow_around(
                    &render_lmap(room, 9, 7, &mut captions),
                    45,
                    ansi!("<reset>  "),
                    &caption_lmap(&captions, 14, 27),
                    31,
                )),
            )
            .await?;
        Ok(())
    }

    async fn map_room_dyn<'a>(
        &self,
        ctx: &VerbContext<'_>,
        zone: &'a dynzone::Dynzone,
        room: &'a dynzone::Dynroom,
        zoneref: &str,
    ) -> UResult<()> {
        let mut captions: Vec<(usize, &str, &str)> = Vec::new();
        let connectwhere_name_opt: Option<String> = match zoneref.split_once("/") {
            None => None,
            Some((zone_t, zone_c)) => {
                let zone_item: Option<Arc<Item>> =
                    ctx.trans.find_item_by_type_code(zone_t, zone_c).await?;
                match zone_item.as_ref().map(|v| v.as_ref()) {
                    Some(Item {
                        special_data:
                            Some(ItemSpecialData::DynzoneData {
                                zone_exit: Some(zone_exit),
                                ..
                            }),
                        ..
                    }) => match zone_exit.split_once("/") {
                        None => None,
                        Some((ex_t, ex_c)) => {
                            match ctx.trans.find_item_by_type_code(ex_t, ex_c).await?.as_ref() {
                                Some(dest_item) => {
                                    Some(dest_item.display_for_sentence(true, 1, true))
                                }
                                None => None,
                            }
                        }
                    },
                    _ => None,
                }
            }
        };
        let lmap_str = render_lmap_dynroom(
            zone,
            room,
            9,
            7,
            &mut captions,
            connectwhere_name_opt.as_ref().map(|v| v.as_str()),
        );
        ctx.trans
            .queue_for_session(
                ctx.session,
                Some(&flow_around(
                    &lmap_str,
                    45,
                    ansi!("<reset>  "),
                    &caption_lmap(&captions, 14, 27),
                    31,
                )),
            )
            .await?;
        Ok(())
    }
}

pub struct GmapType;

#[async_trait]
impl MapType for GmapType {
    async fn map_room(&self, ctx: &VerbContext<'_>, room: &room::Room) -> UResult<()> {
        ctx.trans
            .queue_for_session(ctx.session, Some(&render_map(room, 32, 18)))
            .await?;
        Ok(())
    }

    async fn map_room_dyn<'a>(
        &self,
        ctx: &VerbContext<'_>,
        zone: &'a dynzone::Dynzone,
        room: &'a dynzone::Dynroom,
        _zoneref: &str,
    ) -> UResult<()> {
        ctx.trans
            .queue_for_session(ctx.session, Some(&render_map_dyn(zone, room, 16, 9)))
            .await?;
        Ok(())
    }
}

pub struct Verb;
#[async_trait]
impl UserVerb for Verb {
    async fn handle(
        self: &Self,
        ctx: &mut VerbContext,
        verb: &str,
        remaining: &str,
    ) -> UResult<()> {
        if remaining.trim() != "" {
            user_error("map commands don't take anything after them".to_owned())?;
        }

        let map_type: Box<dyn MapType + Sync + Send> = match verb {
            "lmap" | "lm" => Box::new(LmapType),
            "gmap" | "gm" => Box::new(GmapType),
            _ => user_error("I don't know how to show that map type.".to_owned())?,
        };

        let player_item = get_player_item_or_fail(ctx).await?;
        let (heretype, herecode) = player_item
            .location
            .split_once("/")
            .unwrap_or(("room", "repro_xv_chargen"));
        let room_item: Arc<Item> = ctx
            .trans
            .find_item_by_type_code(heretype, herecode)
            .await?
            .ok_or_else(|| UserError("Sorry, that no longer exists".to_owned()))?;
        if room_item.item_type == "room" {
            let room = room::room_map_by_code()
                .get(room_item.item_code.as_str())
                .ok_or_else(|| UserError("Sorry, that room no longer exists".to_owned()))?;
            map_type.map_room(ctx, &room).await?;
        } else if room_item.item_type == "dynroom" {
            let (dynzone, dynroom) = match &room_item.special_data {
                Some(ItemSpecialData::DynroomData {
                    dynzone_code,
                    dynroom_code,
                }) => dynzone::DynzoneType::from_str(dynzone_code.as_str())
                    .and_then(|dz_t| dynzone::dynzone_by_type().get(&dz_t))
                    .and_then(|dz| dz.dyn_rooms.get(dynroom_code.as_str()).map(|dr| (dz, dr)))
                    .ok_or_else(|| UserError("Dynamic room doesn't exist anymore.".to_owned()))?,
                _ => user_error("Expected dynroom to have DynroomData".to_owned())?,
            };
            map_type
                .map_room_dyn(ctx, &dynzone, &dynroom, &room_item.location)
                .await?;
        } else {
            user_error("Can't map here".to_owned())?;
        }
        Ok(())
    }
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;