1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use miniz_oxide::{deflate::compress_to_vec, inflate::decompress_to_vec};

use crate::{
    io::Source,
    parse::{serde::Serialize, Token, TokenBuilder},
    prebuilt::ver1_46,
    proxy::TriggersProxy,
};
use std::{
    fs::{self, File, OpenOptions},
    io::{Read, Write},
};

pub struct Scenario {
    pub versio: Token,
    version: String,
}

impl Scenario {
    pub fn from_file(filename: &str) -> Self {
        let mut file = File::open(&filename).expect("File not found");
        let metadata = fs::metadata(&filename).expect("Unable to read metadata");
        let mut buffer = vec![0; metadata.len() as usize];
        file.read_exact(&mut buffer).expect("buffer overflow");

        Self::from_le_vec(buffer)
    }

    pub fn from_le_vec(buffer: Vec<u8>) -> Self {
        let version = Self::get_scenario_version(&buffer);
        let mut source = Source::new(buffer);
        match version.as_str() {
            "1.46" => {
                let header = TokenBuilder::create_from_template(
                    &ver1_46::FileHeader::template(),
                    &mut source,
                );

                let mut uncompressed = header.to_le_vec();
                let content = decompress_to_vec(&source.get_rest_vec()).unwrap();
                uncompressed.extend(content);

                let mut source = Source::new(uncompressed);
                Scenario {
                    versio: TokenBuilder::create_from_template(
                        &ver1_46::Versio::template(),
                        &mut source,
                    ),
                    version,
                }
            }
            _ => panic!("Unsupport version!"),
        }
    }

    pub fn to_le_vec(self) -> Vec<u8> {
        self.versio.to_le_vec()
    }

    pub fn to_le_export_vec(self) -> Vec<u8> {
        let file_header = &self.versio.try_map()["file_header"];
        let mut content = file_header.to_le_vec();
        let header_size = content.len();

        let uncompressed = &self.versio.to_le_vec()[header_size..];
        let mut compressed = compress_to_vec(uncompressed, 6);

        content.append(&mut compressed);

        content
    }

    pub fn to_file(self, file_path: &str) {
        let buffer = self.to_le_export_vec();

        let path = std::path::Path::new(file_path);
        let prefix = path.parent().unwrap();
        std::fs::create_dir_all(prefix).unwrap();

        let mut file = OpenOptions::new()
            .create(true)
            .write(true)
            .open(file_path)
            .unwrap();

        file.write_all(&buffer).unwrap();
    }

    pub fn triggers_proxy(&mut self) -> TriggersProxy {
        TriggersProxy::new(&self.version, &mut self.versio)
    }

    fn get_scenario_version(buffer: &[u8]) -> String {
        std::str::from_utf8(&buffer[0..4]).unwrap().to_string()
    }
}