+use std::borrow::Cow;

+use std::env::Args;

+use std::io::{self, Write};

+use std::fs;

+

+use crate::block::{BlockRegistry, build_registry, Rotation};

+use crate::data::dynamic::DynData;

+use crate::data::{DataRead, Serializer, DataWrite, base64};

+use crate::data::schematic::{Schematic, SchematicSerializer};

+use crate::exe::print::print_schematic;

+use crate::exe::print_err;

+use crate::exe::args::{self, ArgCount, ArgOption, OptionHandler};

+use crate::registry::RegistryEntry;

+

+struct State<'l>

+{

+ reg: &'l BlockRegistry<'l>,

+ schematic: Option<Schematic<'l>>,

+ unsaved: bool,

+ quit: bool,

+}

+

+pub fn main(mut args: Args, arg_off: usize)

+{

+ let mut handler = OptionHandler::new();

+ let opt_file = handler.add(ArgOption::new(Some('f'), Some(Cow::Borrowed("file")), ArgCount::Required(1))).unwrap();

+ if let Err(e) = args::parse(&mut args, &mut handler, arg_off)

+ {

+ print_err!(e, "Command error");

+ return;

+ }

+

+ // try to load a schematic from the file argument or as base64

+ let reg = build_registry();

+ let mut ss = SchematicSerializer(&reg);

+ let mut state = State{reg: &reg, schematic: None, unsaved: false, quit: false};

+ if let Some(path) = handler.get_value(opt_file).get_value()

+ {

+ match fs::read(path)

+ {

+ Ok(data) =>

+ {

+ match ss.deserialize(&mut DataRead::new(&data))

+ {

+ Ok(s) =>

+ {

+ println!("Loaded schematic from {path}");

+ state.schematic = Some(s);

+ },

+ Err(e) => print_err!(e, "Could not read schematic from {path}"),

+ }

+ },

+ Err(e) => print_err!(e, "Could not read file {path:?}"),

+ }

+ }

+ else if let Some(b64) = handler.get_literals().first()

+ {

+ match ss.deserialize_base64(b64)

+ {

+ Ok(s) =>

+ {

+ println!("Loaded schematic from CLI");

+ state.schematic = Some(s);

+ },

+ Err(e) => print_err!(e, "Could not read schematic"),

+ }

+ }

+ if state.schematic.is_none()

+ {

+ println!(r#"No active schematic, use "new" or "load" to begin editing."#);

+ }

+ println!(r#"Type "help" for a list of available commands."#);

+

+ // the main command interpreter loop

+ let mut line_buff = String::new();

+ let stdin = io::stdin();

+ while !state.quit

+ {

+ line_buff.clear();

+ print!("> ");

+ if let Err(e) = io::stdout().flush()

+ {

+ // what the print & println macros would do

+ panic!("failed printing to stdout: {e}");

+ }

+ match stdin.read_line(&mut line_buff)

+ {

+ Ok(..) => interpret(&mut state, line_buff.trim_start()),

+ Err(e) =>

+ {

+ print_err!(e, "Failed to read next command");

+ if state.unsaved

+ {

+ // special case because we wouldn't be able to read a path from stdin

+ match ss.serialize_base64(state.schematic.as_ref().unwrap())

+ {

+ Ok(curr) => println!("Current schematic: {curr}"),

+ Err(e) => print_err!(e, "Could not serialize schematic"),

+ }

+ state.unsaved = false;

+ }

+ break;

+ },

+ }

+ }

+

+ // give the user a chance to save their work

+ if state.unsaved

+ {

+ let mut data = DataWrite::new();

+ match ss.serialize(&mut data, state.schematic.as_ref().unwrap())

+ {

+ Ok(()) =>

+ {

+ let data = data.get_written();

+ // SAFETY: base64 output is always valid ASCII

+ let buff = unsafe{line_buff.as_mut_vec()};

+ buff.resize(4 * ((data.len() + 2) / 3), 0);

+ match base64::encode(data, buff)

+ {

+ Ok(len) => println!("Current schematic: {}", &line_buff[..len]),

+ Err(e) => print_err!(e, "Could not convert schematic to base-64"),

+ }

+

+ println!("You have unsaved work. Please type a path to save to or press enter to quit.");

+ loop

+ {

+ line_buff.clear();

+ match stdin.read_line(&mut line_buff)

+ {

+ Ok(..) =>

+ {

+ let path = line_buff.trim();

+ if path.is_empty() {break;}

+ match fs::write(path, data)

+ {

+ Ok(()) => println!("Saved schematic to {path}"),

+ Err(e) => print_err!(e, "Could not write file {path:?}"),

+ }

+ },

+ Err(e) =>

+ {

+ print_err!(e, "Failed to read save path");

+ return;

+ },

+ }

+ }

+ },

+ Err(e) => print_err!(e, "Could not serialize schematic"),

+ }

+ }

+}

+

+struct Tokenizer<'l>(Option<&'l str>);

+

+impl<'l> Tokenizer<'l>

+{

+ fn skip_ws(&mut self)

+ {

+ if let Some(curr) = self.0

+ {

+ let curr = curr.trim_start();

+ self.0 = if curr.is_empty() {None} else {Some(curr)};

+ }

+ }

+

+ fn next(&mut self) -> Option<&'l str>

+ {

+ self.skip_ws();

+ if let Some(curr) = self.0

+ {

+ if curr.len() >= 2 && (curr.as_bytes()[0] == b'"' || curr.as_bytes()[0] == b'\'')

+ {

+ match (&curr[1..]).find(curr.as_bytes()[0] as char)

+ {

+ None =>

+ {

+ self.0 = None;

+ Some(&curr[1..])

+ },

+ Some(end) =>

+ {

+ let rest = &curr[(end + 2)..];

+ self.0 = if rest.is_empty() {None} else {Some(rest)};

+ Some(&curr[1..end])

+ },

+ }

+ }

+ else

+ {

+ match curr.find(char::is_whitespace)

+ {

+ None =>

+ {

+ self.0 = None;

+ Some(curr)

+ },

+ Some(end) =>

+ {

+ let rest = &curr[end..];

+ self.0 = if rest.is_empty() {None} else {Some(rest)};

+ Some(&curr[..end])

+ }

+ }

+ }

+ }

+ else {None}

+ }

+

+ fn remainder(&mut self) -> Option<&'l str>

+ {

+ self.skip_ws();

+ if let Some(curr) = self.0

+ {

+ let bytes = curr.as_bytes();

+ if bytes.len() >= 2 && (bytes[0] == b'"' || bytes[0] == b'\'') && bytes[bytes.len() - 1] == bytes[0]

+ {

+ self.0 = None;

+ return Some(&curr[1..(curr.len() - 1)]);

+ }

+ }

+ let curr = self.0;

+ self.0 = None;

+ curr

+ }

+}

+

+enum Command

+{

+ Help, New, Input, Load, Place, Rotate, Mirror, Remove, Print, Dump, Save, Quit

+}

+

+impl Command

+{

+ fn print_help(&self, indent: usize)

+ {

+ match self

+ {

+ Self::Help => println!("{:<indent$}Prints a list of available commands", "\"help\":"),

+ Self::New => println!("{:<indent$}Creates a new schematic, erasing the currently loaded one", "\"new\":"),

+ Self::Input => println!("{:<indent$}Loads a new schematic from a base-64 encoded string", "\"input\":"),

+ Self::Load => println!("{:<indent$}Loads a new schematic from a file", "\"load\":"),

+ Self::Place => println!("{:<indent$}Places a block if enough space is available", "\"place\":"),

+ Self::Rotate => println!("{:<indent$}Rotates the schematic (CCW) in increments of 90 degrees", "\"rotate\":"),

+ Self::Mirror => println!("{:<indent$}Mirrors the schematic horizontally or vertically", "\"mirror\":"),

+ Self::Remove => println!("{:<indent$}Removes blocks at a position or within a region", "\"remove\":"),

+ Self::Print => println!("{:<indent$}Prints the schematic in a visual representation", "\"print\":"),

+ Self::Dump => println!("{:<indent$}Prints the schematic as a base-64 encoded string", "\"dump\":"),

+ Self::Save => println!("{:<indent$}Saves the schematic to a file", "\"save\":"),

+ Self::Quit => println!("{:<indent$}Offers to save unsaved work and exits the program", "\"quit\":"),

+ }

+ self.print_usage(12);

+ }

+

+ fn print_usage(&self, indent: usize)

+ {

+ match self

+ {

+ Self::Help => (),

+ Self::New => println!(r#"{:indent$} Usage: "new" <width> [<height>]"#, ""),

+ Self::Input => println!(r#"{:indent$} Usage: "input" <base64>"#, ""),

+ Self::Load => println!(r#"{:indent$} Usage: "load" <load path>"#, ""),

+ Self::Place =>

+ {

+ println!(r#"{:indent$} Usage: "place" <x> <y> <block name> [<rotation> [<replace>]]"#, "");

+ println!(r#"{:indent$} Rotation is one of right, up, left, down or compass angles"#, "")

+ },

+ Self::Rotate => println!(r#"{:indent$} Usage: "rotate" <angle>"#, ""),

+ Self::Mirror => println!(r#"{:indent$} Usage: "mirror" <axis>"#, ""),

+ Self::Remove => println!(r#"{:indent$} Usage: "remove" <x0> <y0> [<x1> <y1>]"#, ""),

+ Self::Print | Self::Dump => (),

+ Self::Save => println!(r#"{:indent$} Usage: "save" <save path>"#, ""),

+ Self::Quit => (),

+ }

+ }

+}

+

+macro_rules!parse_num

+{

+ ($cmd:ident, $name:expr, <$type:ty>::from($val:expr)) =>

+ {

+ match $val

+ {

+ None =>

+ {

+ eprintln!("Missing argument: {}", $name);

+ Command::$cmd.print_usage(0);

+ return;

+ },

+ Some(s) =>

+ {

+ match <$type>::from_str_radix(s, 10)

+ {

+ Ok(v) => v,

+ Err(e) =>

+ {

+ print_err!(e, "Could not parse {}", $name);

+ Command::$cmd.print_usage(0);

+ return;

+ },

+ }

+ },

+ }

+ };

+ ($cmd:ident, $tokens:expr, $name:expr, $type:ty) =>

+ {

+ parse_num!($cmd, $name, <$type>::from($tokens.next()))

+ }

+}

+

+fn interpret(state: &mut State, cmd: &str)

+{

+ let mut tokens = Tokenizer(Some(cmd));

+ match tokens.next()

+ {

+ None => println!(r#"Empty command, type "quit" to exit"#),

+ Some("help") =>

+ {

+ println!(r#"List of available commands:"#);

+ Command::Help.print_help(12);

+ Command::New.print_help(12);

+ Command::Input.print_help(12);

+ Command::Load.print_help(12);

+ Command::Place.print_help(12);

+ Command::Rotate.print_help(12);

+ Command::Mirror.print_help(12);

+ Command::Remove.print_help(12);

+ Command::Print.print_help(12);

+ Command::Dump.print_help(12);

+ Command::Save.print_help(12);

+ Command::Quit.print_help(12);

+ println!();

+ println!("Legend: \"literal (excluding quotes)\" <required> [<optional>]");

+ println!("Arguments are delimited by whitespace, unless surrounded with ' or \"");

+ if tokens.remainder().is_some()

+ {

+ eprintln!("Extra arguments are considered an error");

+ }

+ else

+ {

+ println!("Extra arguments are considered an error");

+ }

+ },

+ Some("new") =>

+ {

+ let width = parse_num!(New, tokens, "width", u16);

+ if width == 0

+ {

+ eprintln!("Schematic width must be positive");

+ return;

+ }

+ let height = parse_num!(New, tokens, "height", u16);

+ if height == 0

+ {

+ eprintln!("Schematic height must be positive");

+ return;

+ }

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "new""#);

+ Command::New.print_usage(0);

+ return;

+ }

+ state.schematic = Some(Schematic::new(width, height));

+ // it's empty, no need to save this

+ state.unsaved = false;

+ },

+ Some("input") =>

+ {

+ let schematic = match tokens.next()

+ {

+ None =>

+ {

+ eprintln!("Missing argument: base64");

+ Command::Input.print_usage(0);

+ return;

+ },

+ Some(b64) =>

+ {

+ match SchematicSerializer(state.reg).deserialize_base64(b64)

+ {

+ Ok(s) => s,

+ Err(e) =>

+ {

+ print_err!(e, "Could not deserialize schematic");

+ return;

+ },

+ }

+ },

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "input""#);

+ Command::Input.print_usage(0);

+ return;

+ }

+ state.schematic = Some(schematic);

+ state.unsaved = false;

+ },

+ Some("load") =>

+ {

+ let schematic = match tokens.next()

+ {

+ None =>

+ {

+ eprintln!("Missing argument: load path");

+ Command::Load.print_usage(0);

+ return;

+ },

+ Some(path) =>

+ {

+ let data = match fs::read(path)

+ {

+ Ok(d) => d,

+ Err(e) =>

+ {

+ print_err!(e, "Could not load from file");

+ return;

+ },

+ };

+ match SchematicSerializer(state.reg).deserialize(&mut DataRead::new(&data))

+ {

+ Ok(s) => s,

+ Err(e) =>

+ {

+ print_err!(e, "Could not deserialize schematic");

+ return;

+ },

+ }

+ },

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "load""#);

+ Command::Load.print_usage(0);

+ return;

+ }

+ state.schematic = Some(schematic);

+ state.unsaved = false;

+ },

+ Some("place") =>

+ {

+ let Some(ref mut schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "place" requires an active schematic (see "help")"#);

+ return;

+ };

+ let x = parse_num!(Place, tokens, "x", u16);

+ let y = parse_num!(Place, tokens, "y", u16);

+ if x >= schematic.get_width() || y >= schematic.get_height()

+ {

+ eprintln!("Invalid coordinate ({x} / {y}) out of bounds ({} / {})", schematic.get_width(), schematic.get_height());

+ return;

+ }

+ let block = match tokens.next()

+ {

+ None =>

+ {

+ eprintln!("Missing argument: block name");

+ Command::Place.print_usage(0);

+ return;

+ },

+ Some(name) =>

+ {

+ match state.reg.get(name)

+ {

+ None =>

+ {

+ eprintln!("No such block {name:?}");

+ return;

+ },

+ Some(b) => b,

+ }

+ },

+ };

+ let rot = match tokens.next()

+ {

+ None => None,

+ Some("right") | Some("east") => Some(Rotation::Right),

+ Some("up") | Some("north") => Some(Rotation::Up),

+ Some("left") | Some("west") => Some(Rotation::Left),

+ Some("down") | Some("south") => Some(Rotation::Down),

+ Some(rot) =>

+ {

+ eprintln!("Invalid rotation {rot:?}");

+ return;

+ },

+ };

+ let replace = if rot.is_some()

+ {

+ match tokens.next()

+ {

+ None => None,

+ Some("true") | Some("yes") => Some(true),

+ Some("false") | Some("no") => Some(false),

+ Some(replace) =>

+ {

+ eprintln!("Invalid replacement {replace:?}");

+ return;

+ },

+ }

+ }

+ else {None};

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "place""#);

+ Command::Place.print_usage(0);

+ return;

+ }

+ let rot = rot.unwrap_or(Rotation::Right);

+ let result = if replace.unwrap_or(false)

+ {

+ schematic.replace(x, y, block, DynData::Empty, rot, false).err()

+ }

+ else

+ {

+ schematic.set(x, y, block, DynData::Empty, rot).err()

+ };

+ if let Some(e) = result

+ {

+ print_err!(e, "Failed to place block at {x} / {y}");

+ return;

+ }

+ },

+ Some("rotate") =>

+ {

+ let Some(ref mut schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "rotate" requires an active schematic (see "help")"#);

+ return;

+ };

+ let angle = parse_num!(Rotate, tokens, "angle", i32);

+ if angle % 90 != 0

+ {

+ eprintln!("Rotation angle must be a multiple of 90 degrees");

+ return;

+ }

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "rotate""#);

+ Command::Rotate.print_usage(0);

+ return;

+ }

+ match (angle / 90) % 4

+ {

+ 0 => (),

+ 1 | -3 =>

+ {

+ schematic.rotate(false);

+ state.unsaved = true;

+ },

+ 2 | -2 =>

+ {

+ schematic.rotate_180();

+ state.unsaved = true;

+ },

+ 3 | -1 =>

+ {

+ schematic.rotate(true);

+ state.unsaved = true;

+ },

+ a => unreachable!("angle {angle} -> {a}"),

+ }

+ },

+ Some("mirror") =>

+ {

+ let Some(ref mut schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "mirror" requires an active schematic (see "help")"#);

+ return;

+ };

+ let (x, y) = match tokens.next()

+ {

+ None =>

+ {

+ eprintln!("Missing argument: axis");

+ Command::Mirror.print_usage(0);

+ return;

+ },

+ Some("x") | Some("h") | Some("horizontal") | Some("horizontally") => (true, false),

+ Some("y") | Some("v") | Some("vertical") | Some("vertically") => (false, true),

+ Some("both") | Some("all") => (true, true),

+ Some(axis) =>

+ {

+ eprintln!("Invalid mirroring axis: {axis:?}");

+ return;

+ },

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "mirror""#);

+ Command::Mirror.print_usage(0);

+ return;

+ }

+ schematic.mirror(x, y);

+ state.unsaved = true;

+ },

+ Some("remove") =>

+ {

+ let Some(ref mut schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "remove" requires an active schematic (see "help")"#);

+ return;

+ };

+ let x0 = parse_num!(Remove, tokens, "x0", u16);

+ let y0 = parse_num!(Remove, tokens, "y0", u16);

+ if x0 >= schematic.get_width() || y0 >= schematic.get_height()

+ {

+ eprintln!("Invalid coordinate ({x0} / {y0}) out of bounds ({} / {})", schematic.get_width(), schematic.get_height());

+ return;

+ }

+ let (x0, y0, x1, y1) = if let arg @ Some(..) = tokens.next()

+ {

+ let x1 = parse_num!(Remove, "x1", <u16>::from(arg));

+ let y1 = parse_num!(Remove, tokens, "y1", u16);

+ if x1 >= schematic.get_width() || y1 >= schematic.get_height()

+ {

+ eprintln!("Invalid coordinate ({x1} / {y1}) out of bounds ({} / {})", schematic.get_width(), schematic.get_height());

+ return;

+ }

+ (x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1))

+ }

+ else {(x0, y0, x0, y0)};

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "remove""#);

+ Command::Remove.print_usage(0);

+ return;

+ }

+ if x1 > x0 || y1 > y0

+ {

+ let mut cnt = 0u32;

+ for y in y0..=y1

+ {

+ for x in x0..=x1

+ {

+ // position was already checked while parsing

+ if schematic.take(x, y).unwrap().is_some() {cnt += 1;}

+ }

+ }

+ println!("Removed {cnt} blocks in {x0} / {y0} to {x1} / {y1}");

+ if cnt > 0 {state.unsaved = true;}

+ }

+ else

+ {

+ // position was already checked while parsing

+ match schematic.take(x0, y0).unwrap()

+ {

+ None => (),

+ Some(p) =>

+ {

+ println!("Removed block {} from {x0} / {y0}", p.get_block().get_name());

+ state.unsaved = true;

+ },

+ }

+ }

+ },

+ Some("print") =>

+ {

+ let Some(ref schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "print" requires an active schematic (see "help")"#);

+ return;

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "print""#);

+ Command::Print.print_usage(0);

+ return;

+ }

+ print_schematic(schematic);

+ },

+ Some("dump") =>

+ {

+ let Some(ref schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "dump" requires an active schematic (see "help")"#);

+ return;

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "dump""#);

+ Command::Dump.print_usage(0);

+ return;

+ }

+ let b64 = match SchematicSerializer(state.reg).serialize_base64(schematic)

+ {

+ Ok(b64) => b64,

+ Err(e) =>

+ {

+ print_err!(e, "Could not serialize schematic");

+ return;

+ },

+ };

+ println!("Schematic: {}", b64);

+ },

+ Some("save") =>

+ {

+ let Some(ref schematic) = state.schematic

+ else

+ {

+ eprintln!(r#"Command "save" requires an active schematic (see "help")"#);

+ return;

+ };

+ let Some(path) = tokens.next()

+ else

+ {

+ eprintln!("Missing argument: save path");

+ Command::Save.print_usage(0);

+ return;

+ };

+ if tokens.remainder().is_some()

+ {

+ eprintln!(r#"Too many parameters for "save""#);

+ Command::Save.print_usage(0);

+ return;

+ }

+ let mut serial_buff = DataWrite::new();

+ if let Err(e) = SchematicSerializer(state.reg).serialize(&mut serial_buff, schematic)

+ {

+ print_err!(e, "Could not serialize schematic");

+ return;

+ }

+ if let Err(e) = fs::write(path, serial_buff.get_written())

+ {

+ print_err!(e, "Could not write to file");

+ return;

+ }

+ state.unsaved = false;

+ println!("Saved schematic to {path}.");

+ },

+ Some("quit") => state.quit = true,

+ Some(unknown) => eprintln!("Unknown command {unknown:?}"),

+ }

+}

+pub mod edit;

+ Some(s) if s == "edit" => edit::main(args, 1),

+pub fn print_schematic(s: &Schematic)