path: root/src/main.rs

// © 2022 cos <https://www.netizen.se/>. Please see LICENSE file for details.
//
//! lctns-edit is a quickly prototyped tool to edit name, latitude and longitude in LCTNS.FIT as
//! found on Garmin watches. works for me, but no guarantees are given. if it bricks your device
//! you're responsible, not me.

use {
    anyhow::{
        Context,
        Result,
        anyhow,
    },
    getopts::Options,
    std::{
        env::args,
        error::Error,
        fmt::{
            Display,
            Error as FmtError,
            Formatter,
            Result as FmtResult,
        },
        io::prelude::*,
        iter::repeat,
        fs::File,
        path::Path,
        str::FromStr,
    },
};

/* LCTNS.FIT seems to start with 109 bytes, which we do not know how to parse. After those initial
 * bytes follows the location data in entries of 37 bytes each. One example of such an entry reads
 * as follows:
 *
 * 0     |3                               |19      |23      |27  |29  |31  |33    36|
 * ffffff|4761726d696e2054616977616e000000|c25bd211|4def7f56|0200|e101|820a|ffff02ff|
 *        G a r m i n   T a i w a n        25°3.70' 121°38.'
 *
 * We do not know know how to interpret all of those, but the name and the position are the
 * important ones which this tool cares about.
 */

const MAGIC_INITIAL_BYTES: usize = 109;
const MAGIC_ENTRY_LEN: usize = 37;
const MAGIC_INDEX_NAME: usize = 3;
const MAGIC_LEN_NAME: usize = 16;
const MAGIC_INDEX_LAT: usize = MAGIC_INDEX_NAME + MAGIC_LEN_NAME;
const MAGIC_LEN_LAT: usize = 4;
const MAGIC_INDEX_LONG: usize = MAGIC_INDEX_LAT + MAGIC_LEN_LAT;
const MAGIC_LEN_LONG: usize = 4;
// 29-30 is likely the icon and 31-32 might be the altitude, but those are merely my guesses.

// TODO Latitude and Longitude are almost identical. It would be a good idea to refactor them to
//      reuse the common code.
struct Latitude {
    inner: i32,
}

impl Latitude {
    /// Creates a [Latitude] using `val` in the format used in the FIT file.
    fn from_fit(val: i32) -> Self {
        Self {
            inner: val,
        }
    }
}

impl Display for Latitude {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
        // TODO Output localized strings.
        let div = ((1i64 << 32) as f32) / 360f32;
        let deg = self.inner as f32 / div;
        let min = deg.fract()*60f32;
        let sec = min.fract()*60f32;

        if deg >= 0f32 {
            write!(f, "N {}°{}'{:.3}\"", deg.trunc(), min.trunc(), sec)
        } else {
            write!(f, "S {}°{}'{:.3}\"", -deg.trunc(), -min.trunc(), -sec)
        }
    }
}

#[derive(Debug)]
struct ParseError { }

impl Error for ParseError { }

impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "Parse error")
    }
}

// FIXME This function gets the parsing done, but it is horribly written and lacking in e.g. error
//       checking. There is a latlon crate which claims to do this kind of parsing but with
//       datatypes generally used for geo. Any attempt to interface with the greater eco-system
//       pulls in quite some heavy dependences though.
impl TryFrom<&str> for Latitude {
    type Error = ParseError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        let mul = ((1i64 << 32) as f32) / 360f32;

        let mut degrees = None;
        let mut minutes = None;
        let mut seconds = None;
        let mut index = 0;

        let sign = if s.contains('N') {
            1f32
        } else if s.contains('S') {
            -1f32
        } else {
            return Err(ParseError { });
        };

        if let Some(deg_sign_pos) = s.find('°') {
            while index < deg_sign_pos {
                if let Ok(val) = f32::from_str(&s[index..deg_sign_pos]) {
                    degrees = Some(val);
                    index = deg_sign_pos;
                    break;
                }
                index += 1;
            }
        }
        index += 2; // Degree character is dual-byte.
        if let Some(min_sign) = s.find('\'') {
            while index < min_sign {
                if let Ok(val) = f32::from_str(&s[index..min_sign]) {
                    minutes = Some(val);
                    index = min_sign;
                    break;
                }
                index += 1;
            }
        }
        if let Some(sec_sign) = s.find('"') {
            while index < sec_sign {
                if let Ok(val) = f32::from_str(&s[index..sec_sign]) {
                    seconds = Some(val);
                    break;
                }
                index += 1;
            }
        }
        match (degrees, minutes, seconds) {
            (Some(deg), None, None) => Ok(Latitude { inner: (sign * mul * deg) as i32 }),
            (Some(deg), Some(min), None) =>
                Ok(Latitude { inner: (sign * mul * (deg + min / 60f32)) as i32 }),
            (Some(deg), Some(min), Some(sec)) =>
                Ok(Latitude { inner: (sign * mul * (deg + min / 60f32 + sec / 3600f32)) as i32 }),
            _ => Err(ParseError { }),
        }
    }
}

struct Longitude {
    inner: i32,
}

impl Longitude {
    fn from_fit(val: i32) -> Self {
        Self {
            inner: val,
        }
    }
}

impl Display for Longitude {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
        let div = ((1i64 << 32) as f32) / 360f32;
        let deg = self.inner as f32 / div;
        let min = deg.fract()*60f32;
        let sec = min.fract()*60f32;

        if deg >= 0f32 {
            write!(f, "E {}°{}'{:.3}\"", deg.trunc(), min.trunc(), sec)
        } else {
            write!(f, "W {}°{}'{:.3}\"", -deg.trunc(), -min.trunc(), -sec)
        }
    }
}

impl TryFrom<&str> for Longitude {
    type Error = ParseError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        let mul = ((1i64 << 32) as f32) / 360f32;

        let mut degrees = None;
        let mut minutes = None;
        let mut seconds = None;
        let mut index = 0;

        let sign = if s.contains('E') {
            1f32
        } else if s.contains('W') {
            -1f32
        } else {
            return Err(ParseError { });
        };

        if let Some(deg_sign_pos) = s.find('°') {
            while index < deg_sign_pos {
                if let Ok(val) = f32::from_str(&s[index..deg_sign_pos]) {
                    degrees = Some(val);
                    index = deg_sign_pos;
                    break;
                }
                index += 1;
            }
        }
        index += 2; // Degree character is dual-byte.
        if let Some(min_sign) = s.find('\'') {
            while index < min_sign {
                if let Ok(val) = f32::from_str(&s[index..min_sign]) {
                    minutes = Some(val);
                    index = min_sign;
                    break;
                }
                index += 1;
            }
        }
        if let Some(sec_sign) = s.find('"') {
            while index < sec_sign {
                if let Ok(val) = f32::from_str(&s[index..sec_sign]) {
                    seconds = Some(val);
                    break;
                }
                index += 1;
            }
        }
        match (degrees, minutes, seconds) {
            (Some(deg), None, None) => Ok(Longitude { inner: (sign * mul * deg) as i32 }),
            (Some(deg), Some(min), None) =>
                Ok(Longitude { inner: (sign * mul * (deg + min / 60f32)) as i32 }),
            (Some(deg), Some(min), Some(sec)) =>
                Ok(Longitude { inner: (sign * mul * (deg + min / 60f32 + sec / 3600f32)) as i32 }),
            _ => Err(ParseError { }),
        }
    }
}

struct LctnEntry<'lctns> {
    raw_slice: &'lctns [u8],
}

impl<'lctns> LctnEntry<'lctns> {
    fn new(raw_slice: &'lctns [u8]) -> Self {
        Self {
            raw_slice,
        }
    }

    fn name(&self) -> String {
        let slice = &self.raw_slice[MAGIC_INDEX_NAME..MAGIC_INDEX_NAME + MAGIC_LEN_NAME];
        String::from_utf8_lossy(slice).to_string()
    }

    fn lat(&self) -> i32 {
        let slice = &self.raw_slice[MAGIC_INDEX_LAT..MAGIC_INDEX_LAT + MAGIC_LEN_LAT];
        i32::from_le_bytes(slice.try_into().expect("Latitude error"))
    }

    fn long(&self) -> i32 {
        let slice = &self.raw_slice[MAGIC_INDEX_LONG..MAGIC_INDEX_LONG + MAGIC_LEN_LONG];
        i32::from_le_bytes(slice.try_into().expect("Longitude error"))
    }
}

impl Display for LctnEntry<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
        let latitude = Latitude::from_fit(self.lat());
        let longitude = Longitude::from_fit(self.long());
        write!(f, "{} ({}, {})", self.name(), latitude, longitude)
    }
}

struct LctnEntryMut<'lctns> {
    raw_slice: &'lctns mut [u8],
}

impl<'lctns> LctnEntryMut<'lctns> {
    fn set_name(&mut self, name: String) {
        let iter = name.as_bytes().iter().chain(repeat(&b'\0')).enumerate();
        for (index, byte) in iter {
            if index > MAGIC_LEN_NAME {
                break;
            }
            self.raw_slice[MAGIC_INDEX_NAME + index] = *byte;
        }
    }

    fn set_lat(&mut self, lat: i32) {
        let slice = i32::to_le_bytes(lat);
        for (index, byte) in slice.into_iter().enumerate() {
            self.raw_slice[MAGIC_INDEX_LAT + index] = byte;
        }
    }

    fn set_long(&mut self, long: i32) {
        let slice = i32::to_le_bytes(long);
        for (index, byte) in slice.into_iter().enumerate() {
            self.raw_slice[MAGIC_INDEX_LONG + index] = byte;
        }
    }
}

impl Display for LctnEntryMut<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
        let entry = LctnEntry::new(self.raw_slice);
        write!(f, "{}", &entry)
    }
}

struct Lctns {
    raw_data: Vec<u8>,
}

impl Lctns {
    fn new<F: AsRef<Path>>(filename: F) -> Result<Self> {
        let mut lctns = Lctns {
            raw_data: Vec::new(),
        };

        let mut f = File::open(filename)?;
        lctns.raw_data = Vec::new();
        f.read_to_end(&mut lctns.raw_data)?;
        Ok(lctns)
    }

    fn save<F: AsRef<Path>>(&self, filename: F) -> Result<()> {
        let mut f = File::create(filename)?;
        f.write(&self.raw_data).map(|_| ()).context("Save failed")
    }

    fn len(&self) -> usize {
        (self.raw_data.len() - MAGIC_INITIAL_BYTES) / MAGIC_ENTRY_LEN
    }

    fn get(&self, index: usize) -> Option<LctnEntry> {
        let start = MAGIC_INITIAL_BYTES + index * MAGIC_ENTRY_LEN;
        let end = MAGIC_INITIAL_BYTES + (index + 1) * MAGIC_ENTRY_LEN;
        Some(LctnEntry {
            raw_slice: &self.raw_data[start..end],
        })
    }

    fn get_mut(&mut self, index: usize) -> Option<LctnEntryMut> {
        let start = MAGIC_INITIAL_BYTES + index * MAGIC_ENTRY_LEN;
        let end = MAGIC_INITIAL_BYTES + (index + 1) * MAGIC_ENTRY_LEN;
        Some(LctnEntryMut {
            raw_slice: &mut self.raw_data[start..end],
        })
    }

    fn show_all(&self) -> Result<()> {
        for index in 0..self.len() {
            println!("{:4}: {}", index, self.get(index).unwrap());
        }
        Ok(())
    }

    fn _hexdump(&self) -> Result<()> {
        let mut left = String::default();
        let mut right = String::default();
        let buffer = &self.raw_data[MAGIC_INITIAL_BYTES..]; // Ignore stuff at start of file.

        for (index, byte) in buffer.iter().enumerate() {
            if index % MAGIC_ENTRY_LEN == 0 {
                println!("{left} {right}\n");
                left = format!("{:04}  ", index);
                right = String::default();
                println!("{}", self.get(index/MAGIC_ENTRY_LEN).unwrap());
            }
            left += &format!("{:02x} ", byte);
            if byte > &32 && byte < &127 {
                right += std::str::from_utf8(&buffer[index..index+1]).unwrap();
            } else {
                right += "_";
            }
        }
        println!("{left} {right}");
        Ok(())
    }
}

fn print_usage(program: &str, opts: Options) {
    let brief = format!("Usage: {}", program);
    print!("{}", opts.usage(&brief));
}

fn main() -> Result<()> {
    let args: Vec<String> = args().collect();
    let program = args[0].clone();
    let mut index = None;

    let mut opts = Options::new();
    opts.optopt("i", "input", "FILE", "");
    opts.optopt("o", "output", "FILE", "");
    opts.optopt("e", "entry", "NUM", "");
    opts.optopt("n", "name", "NAME", "");
    // While "λ" and "φ" would be reasonable for "latitude" and "longitude", the getopts crate
    // seems to only allow ascii for the short name. Thus they end up with only their long ones.
    opts.optopt("", "latitude", "N|S deg°[min'sec\"]", "");
    opts.optopt("", "longitude", "E|W deg°[min'sec\"]", "");
    opts.optflag("h", "help", "Print this help text");
    let matches = opts.parse(&args[1..])?;
    if matches.opt_present("help") {
        print_usage(&program, opts);
        return Ok(());
    }

    let mut lctns = Lctns::new(matches.opt_str("input")
        .unwrap_or_else(|| String::from("LCTNS.FIT")))?;
    let output = matches.opt_str("output");
    let mut save = false;
    if let Some(string) = matches.opt_str("entry") {
        let highest = lctns.len();
        let i = string.parse()?;
        if i < highest {
            index = Some(i);
        } else {
            Err(anyhow!("{i} is too large. There are only {highest} number of records in file."))?;
        }
    }
    if let Some(i) = index {
        let mut entry = lctns.get_mut(i).ok_or_else(|| anyhow!("No entry at {i}"))?;
        if let Some(name) = matches.opt_str("name") {
            save = true;
            entry.set_name(name);
        }
        if let Some(lat) = matches.opt_str("latitude") {
            save = true;
            let raw: Latitude = lat.as_str().try_into()?;
            entry.set_lat(raw.inner);
        }
        if let Some(long) = matches.opt_str("longitude") {
            save = true;
            let raw: Longitude = long.as_str().try_into()?;
            entry.set_long(raw.inner);
        }
        println!("{entry}");
    } else if matches.opt_str("name").is_some() || matches.opt_str("latitude") .is_some() ||
            matches.opt_str("longitude").is_some() || matches.opt_str("output").is_some()
    {
        Err(anyhow!("Updates requires selecting an entry. (Using: --entry NUM)"))?;
    } else {
        lctns.show_all()?;
    }

    if save && output.is_some() {
        lctns.save(output.unwrap())?; // Ok to unwrap(), previous line checks for is_some()
    }

    Ok(())
}