use crate::{
    optional_data_line, Avatar, Dialogue, Ending, Font, Item, Palette, Room, Sprite, TextDirection,
    Tile, ToBase36, Variable,
};
use std::error::Error;

#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub struct Version {
    pub major: u8,
    pub minor: u8,
}

impl Version {
    fn from(str: &str) -> Version {
        let parts: Vec<&str> = str.split(".").collect();
        assert_eq!(parts.len(), 2);
        Version {
            major: parts[0].parse().unwrap(),
            minor: parts[1].parse().unwrap(),
        }
    }
}

#[derive(Debug, PartialEq)]
pub struct Game {
    pub name: String,
    pub version: Option<Version>,
    pub room_format: u8, // this is "0 = non-comma separated, 1 = comma separated" apparently
    pub font: Font,
    pub custom_font: Option<String>, // used if font is Font::Custom
    pub text_direction: TextDirection,
    pub palettes: Vec<Palette>,
    pub rooms: Vec<Room>,
    pub tiles: Vec<Tile>,
    pub avatar: Avatar,
    pub sprites: Vec<Sprite>,
    pub items: Vec<Item>,
    pub dialogues: Vec<Dialogue>,
    pub endings: Vec<Ending>,
    pub variables: Vec<Variable>,
    pub font_data: Option<String>, // todo make this an actual struct for parsing
}

impl Game {
    pub fn from(string: String) -> Result<Game, &'static dyn Error> {
        let mut string = format!("{}\n\n", string.trim_matches('\n'));

        if string.starts_with("# BITSY VERSION") {
            string = format!("\n\n{}", string);
        }

        let string = string;

        // dialogues and endings can have 2+ line breaks inside, so deal with these separately
        // otherwise, everything can be split on a double line break (\n\n)
        let mut dialogues: Vec<Dialogue> = Vec::new();
        let mut endings: Vec<Ending> = Vec::new();
        let mut variables: Vec<Variable> = Vec::new();
        let mut font_data: Option<String> = None;
        let main_split: Vec<&str> = string.split("\n\nDLG").collect();
        let main = main_split[0].to_string();
        let mut extra: String = main_split[1..].join("\n\nDLG");

        if extra.contains("\n\nFONT") {
            let parts = extra.clone();
            let parts: Vec<&str> = parts.split("\n\nFONT").collect();
            font_data = Some(format!("FONT{}", parts[1]));
        }

        let variable_segments = extra.clone();
        let variable_segments: Vec<&str> = variable_segments.split("\n\nVAR").collect();
        if variable_segments.len() > 0 {
            extra = variable_segments[0].to_string();
            let variable_segments = variable_segments[1..].to_owned();

            for segment in variable_segments {
                let segment = format!("VAR{}", segment);
                variables.push(Variable::from(segment));
            }
        }

        let ending_segments = extra.clone();
        let ending_segments: Vec<&str> = ending_segments.split("\n\nEND").collect();
        if ending_segments.len() > 0 {
            extra = ending_segments[0].to_string();
            let ending_segments = ending_segments[1..].to_owned();

            for segment in ending_segments {
                let segment = format!("END{}", segment);
                endings.push(Ending::from(segment));
            }
        }

        let dialogue_segments =
            format!("\n\nDLG{}", extra.trim_matches('\n'));

        let dialogue_segments: Vec<&str> = dialogue_segments.split("\n\nDLG").collect();
        for segment in dialogue_segments[1..].to_owned() {
            let segment = format!("DLG{}", segment);
            dialogues.push(Dialogue::from(segment));
        }

        let segments: Vec<&str> = main.split("\n\n").collect();

        let name = segments[0].to_string();
        let mut version = None;
        let mut room_format: u8 = 1;
        let mut font = Font::AsciiSmall;
        let mut custom_font = None;
        let mut text_direction = TextDirection::LeftToRight;
        let mut palettes: Vec<Palette> = Vec::new();
        let mut rooms: Vec<Room> = Vec::new();
        let mut tiles: Vec<Tile> = Vec::new();
        let mut avatar: Option<Avatar> = None; // unwrap this later
        let mut sprites: Vec<Sprite> = Vec::new();
        let mut items: Vec<Item> = Vec::new();

        for segment in segments[1..].to_owned() {
            let segment = segment.to_string();

            if segment.starts_with("# BITSY VERSION") {
                let segment = segment.replace("# BITSY VERSION ", "");
                version = Some(Version::from(&segment));
            } else if segment.starts_with("! ROOM_FORMAT") {
                room_format = segment.replace("! ROOM_FORMAT ", "").parse().unwrap();
            } else if segment.starts_with("DEFAULT_FONT") {
                let segment = segment.replace("DEFAULT_FONT ", "");

                font = Font::from(&segment);

                if font == Font::Custom {
                    custom_font = Some(segment.to_string());
                }
            } else if segment.trim() == "TEXT_DIRECTION RTL".to_string() {
                text_direction = TextDirection::RightToLeft;
            } else if segment.starts_with("PAL") {
                palettes.push(Palette::from(segment));
            } else if segment.starts_with("ROOM") || segment.starts_with("SET") {
                rooms.push(Room::from(segment));
            } else if segment.starts_with("TIL") {
                tiles.push(Tile::from(segment));
            } else if segment.starts_with("SPR A") {
                avatar = Some(Avatar::from(segment).unwrap());
            } else if segment.starts_with("SPR") {
                sprites.push(Sprite::from(segment));
            } else if segment.starts_with("ITM") {
                items.push(Item::from(segment));
            }
        }

        assert!(avatar.is_some());
        let avatar = avatar.unwrap();

        Ok(Game {
            name,
            version,
            room_format,
            font,
            custom_font,
            text_direction,
            palettes,
            rooms,
            tiles,
            avatar,
            sprites,
            items,
            dialogues,
            endings,
            variables,
            font_data,
        })
    }
}

impl ToString for Game {
    #[inline]
    fn to_string(&self) -> String {
        let mut segments: Vec<String> = Vec::new();

        // todo refactor

        for palette in &self.palettes {
            segments.push(palette.to_string());
        }

        for room in &self.rooms {
            segments.push(room.to_string());
        }

        for tile in &self.tiles {
            segments.push(tile.to_string());
        }

        // for some reason the sprites with numeric IDs go first,
        // then SPR A (avatar), then all the non-numeric IDs
        fn is_string_numeric(str: String) -> bool {
            for c in str.chars() {
                if !c.is_numeric() {
                    return false;
                }
            }

            return true;
        }

        for sprite in &self.sprites {
            if is_string_numeric(sprite.id.to_base36()) {
                segments.push(sprite.to_string());
            }
        }

        segments.push(self.avatar.to_string());

        for sprite in &self.sprites {
            if !is_string_numeric(sprite.id.to_base36()) {
                segments.push(sprite.to_string());
            }
        }

        for item in &self.items {
            segments.push(item.to_string());
        }

        for dialogue in &self.dialogues {
            segments.push(dialogue.to_string());
        }

        for ending in &self.endings {
            segments.push(ending.to_string());
        }

        for variable in &self.variables {
            segments.push(variable.to_string());
        }

        if self.font_data.is_some() {
            segments.push(self.font_data.to_owned().unwrap())
        }

        format!(
            "{}\n{}\n{}{}{}\n\n{}\n\n",
            &self.name,
            &self.version_line(),
            &self.room_format_line(),
            &self.font_line(),
            &self.text_direction_line(),
            segments.join("\n\n"),
        )
    }
}

impl Game {
    pub fn tile_ids(&self) -> Vec<u64> {
        self.tiles.iter().map(|tile| tile.id).collect()
    }

    /// first available tile ID.
    /// e.g. if current tile IDs are [0, 2, 3] the result will be `1`
    ///      if current tile IDs are [0, 1, 2] the result will be `3`
    pub fn new_tile_id(&self) -> u64 {
        let mut new_id = 0;

        let mut ids = self.tile_ids();
        ids.sort();

        for id in ids {
            if new_id == id {
                new_id += 1;
            } else {
                return new_id;
            }
        }

        new_id + 1
    }
    /// adds a tile safely and returns the new tile ID
    pub fn add_tile(&mut self, mut tile: Tile) -> u64 {
        let new_id = self.new_tile_id();
        tile.id = new_id;
        self.tiles.push(tile);
        new_id
    }

    fn version_line(&self) -> String {
        if self.version.is_some() {
            format!(
                "\n# BITSY VERSION {}.{}",
                self.version.as_ref().unwrap().major, self.version.as_ref().unwrap().minor
            )
        } else {
            "".to_string()
        }
    }

    fn room_format_line(&self) -> String {
        optional_data_line("! ROOM_FORMAT", Some(self.room_format))
    }

    fn font_line(&self) -> String {
        if self.font == Font::AsciiSmall {
            "".to_string()
        } else {
            if self.font == Font::Custom {
                format!("\n\nDEFAULT_FONT {}", self.custom_font.as_ref().unwrap())
            } else {
                format!("\n\nDEFAULT_FONT {}", self.font.to_string().unwrap())
            }
        }
    }

    fn text_direction_line(&self) -> &str {
        if self.text_direction == TextDirection::RightToLeft {
            "\n\nTEXT_DIRECTION RTL"
        } else {
            ""
        }
    }

    /// older bitsy games do not specify a version, but we can infer 1.0
    pub fn version(&self) -> Version {
        self.version.unwrap_or(Version { major: 1, minor: 0 })
    }
}

#[cfg(test)]
mod test {
    use crate::game::{Version, Game};
    use crate::text::{TextDirection, Font};
    use crate::tile::Tile;

    #[test]
    fn test_game_from_string() {
        let output = Game::from(include_str!["test-resources/default.bitsy"].to_string()).unwrap();
        let expected = crate::mock::game_default();

        assert_eq!(output, expected);
    }

    #[test]
    fn test_game_to_string() {
        let output = crate::mock::game_default().to_string();
        let expected = include_str!["test-resources/default.bitsy"].to_string();
        assert_eq!(output, expected);
    }

    #[test]
    fn test_tile_ids() {
        assert_eq!(crate::mock::game_default().tile_ids(), vec![10]);
    }

    #[test]
    fn test_new_tile_id() {
        // default tile has an id of 10 ("a"), so 0 is available
        assert_eq!(crate::mock::game_default().new_tile_id(), 0);

        let mut game = crate::mock::game_default();
        let mut tiles: Vec<Tile> = Vec::new();

        for n in 0..9 {
            if n != 4 {
                let mut new_tile = crate::mock::tile_default();
                new_tile.id = n;
                tiles.push(new_tile);
            }
        }

        game.tiles = tiles;

        assert_eq!(game.new_tile_id(), 4);

        // fill in the space created above, and test that tile IDs get sorted

        let mut new_tile = crate::mock::tile_default();
        new_tile.id = 4;
        game.tiles.push(new_tile);

        assert_eq!(game.new_tile_id(), 10);
    }

    #[test]
    fn test_add_tile() {
        let mut game = crate::mock::game_default();
        let new_id = game.add_tile(crate::mock::tile_default());
        assert_eq!(new_id, 0);
        assert_eq!(game.tiles.len(), 2);
        let new_id = game.add_tile(crate::mock::tile_default());
        assert_eq!(new_id, 1);
        assert_eq!(game.tiles.len(), 3);
    }

    #[test]
    fn test_bitsy_omnibus() {
        let acceptable_failures: Vec<String> = vec![
            // fails because of sprite colours but also because a tile contains "NaN"
            "src/test-resources/omnibus/DA88C287.bitsy.txt".to_string(),
            // SET instead of ROOM? todo investigate
            "src/test-resources/omnibus/1998508E.bitsy.txt".to_string(),
            "src/test-resources/omnibus/046871F8.bitsy.txt".to_string(),
            // not sure about this one but it uses room wall array
            "src/test-resources/omnibus/748F77B5.bitsy.txt".to_string(),
            // bad game data
            "src/test-resources/omnibus/14C48FA0.bitsy.txt".to_string(),
            "src/test-resources/omnibus/C63A0633.bitsy.txt".to_string(),
            "src/test-resources/omnibus/C63A0633.bitsy.txt".to_string(),
            "src/test-resources/omnibus/013B3CDE.bitsy.txt".to_string(), // NaN in image
            // this one has font data appended to the end of the game data - is this valid?
            "src/test-resources/omnibus/4B4EB988.bitsy.txt".to_string(),
            // has an ending position of -1
            "src/test-resources/omnibus/593BD9A6.bitsy.txt".to_string(),
            // extra line between dialogues
            "src/test-resources/omnibus/DB59A848.bitsy.txt".to_string(),
            // something going on with dialogues? todo investigate
            "src/test-resources/omnibus/807805CC.bitsy.txt".to_string(),
            "src/test-resources/omnibus/C36E27E5.bitsy.txt".to_string(),
            "src/test-resources/omnibus/354DA56F.bitsy.txt".to_string(),
            // this avatar has `ITM 0 1` - can the player start with an item? todo investigate
            "src/test-resources/omnibus/CC5085BE.bitsy.txt".to_string(),
            "src/test-resources/omnibus/20D06BD1.bitsy.txt".to_string(),
        ];

        let mut passes = 0;
        let mut skips = 0;

        let files = std::fs::read_dir("src/test-resources/omnibus");

        if !files.is_ok() {
            return;
        }

        for file in files.unwrap() {
            let path = file.unwrap().path();
            let nice_name = format!("{}", path.display());

            if !nice_name.contains("bitsy") || acceptable_failures.contains(&nice_name) {
                skips += 1;
                // println!("Skipping: {}", nice_name);
                println!("Skipped. {} passes, {} skips.", passes, skips);
                continue;
            }

            println!("Testing: {}...", path.display());
            let game_data = std::fs::read_to_string(path).unwrap();
            let game = Game::from(game_data.clone()).unwrap();
            assert_eq!(
                game.to_string().trim_matches('\n'),
                game_data.trim_matches('\n')
            );
            passes += 1;
            println!("Success! {} passes, {} skips.", passes, skips);
        }
    }

    #[test]
    fn test_arabic() {
        let game = Game::from(include_str!("test-resources/arabic.bitsy").to_string()).unwrap();

        assert_eq!(game.font, Font::Arabic);
        assert_eq!(game.text_direction, TextDirection::RightToLeft);
    }

    #[test]
    fn test_version_formatting() {
        let mut game = crate::mock::game_default();
        game.version = Some(Version { major: 5, minor: 0 });
        assert!(game.to_string().contains("# BITSY VERSION 5.0"))
    }
}