rustyfit 0.8.1

// Code generated by fitgen/main.go. DO NOT EDIT.

// Copyright 2025 The RustyFIT Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#![allow(unused, clippy::manual_range_patterns)]

use crate::profile::{ProfileType, typedef};
use crate::proto::*;
use alloc::vec::Vec;

#[derive(Debug, Clone)]
/// DeviceSettings is a DeviceSettings message.
pub struct DeviceSettings {
    /// Index into time zone arrays.
    pub active_time_zone: u8,
    /// Offset from system time. Required to convert timestamp from system time to UTC.
    pub utc_offset: u32,
    /// Units: s; Offset from system time.
    pub time_offset: Vec<u32>,
    /// Display mode for the time
    pub time_mode: Vec<typedef::TimeMode>,
    /// Scale: 4; Units: hr; timezone offset in 1/4 hour increments
    pub time_zone_offset: Vec<i8>,
    /// Mode for backlight
    pub backlight_mode: typedef::BacklightMode,
    /// Enabled state of the activity tracker functionality
    pub activity_tracker_enabled: typedef::Bool,
    /// UTC timestamp used to set the devices clock and date
    pub clock_time: typedef::DateTime,
    /// Bitfield to configure enabled screens for each supported loop
    pub pages_enabled: Vec<u16>,
    /// Enabled state of the move alert
    pub move_alert_enabled: typedef::Bool,
    /// Display mode for the date
    pub date_mode: typedef::DateMode,
    pub display_orientation: typedef::DisplayOrientation,
    pub mounting_side: typedef::Side,
    /// Bitfield to indicate one page as default for each supported loop
    pub default_page: Vec<u16>,
    /// Units: steps; Minimum steps before an autosync can occur
    pub autosync_min_steps: u16,
    /// Units: minutes; Minimum minutes before an autosync can occur
    pub autosync_min_time: u16,
    /// Enable auto-detect setting for the lactate threshold feature.
    pub lactate_threshold_autodetect_enabled: typedef::Bool,
    /// Automatically upload using BLE
    pub ble_auto_upload_enabled: typedef::Bool,
    /// Helps to conserve battery by changing modes
    pub auto_sync_frequency: typedef::AutoSyncFrequency,
    /// Allows setting specific activities auto-activity detect enabled/disabled settings
    pub auto_activity_detect: typedef::AutoActivityDetect,
    /// Number of screens configured to display
    pub number_of_screens: u8,
    /// Smart Notification display orientation
    pub smart_notification_display_orientation: typedef::DisplayOrientation,
    pub tap_interface: typedef::Switch,
    /// Used to hold the tap threshold setting
    pub tap_sensitivity: typedef::TapSensitivity,
    /// unknown_fields are fields that are exist but they are not defined in Profile.xlsx
    pub unknown_fields: Vec<Field>,
    /// developer_fields are custom data fields (Added since protocol version 2.0)
    pub developer_fields: Vec<DeveloperField>,
}

impl DeviceSettings {
    /// Value's type: `u8`
    pub const ACTIVE_TIME_ZONE: u8 = 0;
    /// Value's type: `u32`
    pub const UTC_OFFSET: u8 = 1;
    /// Value's type: `Vec<u32>`; Units: `s`
    pub const TIME_OFFSET: u8 = 2;
    /// Value's type: `Vec<u8>`
    pub const TIME_MODE: u8 = 4;
    /// Value's type: `Vec<i8>`; Scale: `4`; Units: `hr`
    pub const TIME_ZONE_OFFSET: u8 = 5;
    /// Value's type: `u8`
    pub const BACKLIGHT_MODE: u8 = 12;
    /// Value's type: `u8`
    pub const ACTIVITY_TRACKER_ENABLED: u8 = 36;
    /// Value's type: `u32`
    pub const CLOCK_TIME: u8 = 39;
    /// Value's type: `Vec<u16>`
    pub const PAGES_ENABLED: u8 = 40;
    /// Value's type: `u8`
    pub const MOVE_ALERT_ENABLED: u8 = 46;
    /// Value's type: `u8`
    pub const DATE_MODE: u8 = 47;
    /// Value's type: `u8`
    pub const DISPLAY_ORIENTATION: u8 = 55;
    /// Value's type: `u8`
    pub const MOUNTING_SIDE: u8 = 56;
    /// Value's type: `Vec<u16>`
    pub const DEFAULT_PAGE: u8 = 57;
    /// Value's type: `u16`; Units: `steps`
    pub const AUTOSYNC_MIN_STEPS: u8 = 58;
    /// Value's type: `u16`; Units: `minutes`
    pub const AUTOSYNC_MIN_TIME: u8 = 59;
    /// Value's type: `u8`
    pub const LACTATE_THRESHOLD_AUTODETECT_ENABLED: u8 = 80;
    /// Value's type: `u8`
    pub const BLE_AUTO_UPLOAD_ENABLED: u8 = 86;
    /// Value's type: `u8`
    pub const AUTO_SYNC_FREQUENCY: u8 = 89;
    /// Value's type: `u32`
    pub const AUTO_ACTIVITY_DETECT: u8 = 90;
    /// Value's type: `u8`
    pub const NUMBER_OF_SCREENS: u8 = 94;
    /// Value's type: `u8`
    pub const SMART_NOTIFICATION_DISPLAY_ORIENTATION: u8 = 95;
    /// Value's type: `u8`
    pub const TAP_INTERFACE: u8 = 134;
    /// Value's type: `u8`
    pub const TAP_SENSITIVITY: u8 = 174;

    /// Create new DeviceSettings with all fields being set to its corresponding invalid value.
    pub const fn new() -> Self {
        Self {
            active_time_zone: u8::MAX,
            utc_offset: u32::MAX,
            time_offset: Vec::new(),
            time_mode: Vec::new(),
            time_zone_offset: Vec::new(),
            backlight_mode: typedef::BacklightMode(u8::MAX),
            activity_tracker_enabled: typedef::Bool(u8::MAX),
            clock_time: typedef::DateTime(u32::MAX),
            pages_enabled: Vec::new(),
            move_alert_enabled: typedef::Bool(u8::MAX),
            date_mode: typedef::DateMode(u8::MAX),
            display_orientation: typedef::DisplayOrientation(u8::MAX),
            mounting_side: typedef::Side(u8::MAX),
            default_page: Vec::new(),
            autosync_min_steps: u16::MAX,
            autosync_min_time: u16::MAX,
            lactate_threshold_autodetect_enabled: typedef::Bool(u8::MAX),
            ble_auto_upload_enabled: typedef::Bool(u8::MAX),
            auto_sync_frequency: typedef::AutoSyncFrequency(u8::MAX),
            auto_activity_detect: typedef::AutoActivityDetect(u32::MAX),
            number_of_screens: u8::MAX,
            smart_notification_display_orientation: typedef::DisplayOrientation(u8::MAX),
            tap_interface: typedef::Switch(u8::MAX),
            tap_sensitivity: typedef::TapSensitivity(u8::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }

    /// Returns `time_zone_offset` in its scaled value. It returns invalid f64 when value is valid.
    pub fn time_zone_offset_scaled(&self) -> Vec<f64> {
        if self.time_zone_offset.is_empty() {
            return Vec::new();
        }
        let mut v = Vec::with_capacity(self.time_zone_offset.len());
        for &x in &self.time_zone_offset {
            v.push(x as f64 / 4.0 - 0.0)
        }
        v
    }

    /// Set `time_zone_offset` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_time_zone_offset_scaled(&mut self, v: &Vec<f64>) -> &mut DeviceSettings {
        if v.is_empty() {
            self.time_zone_offset = Vec::new();
            return self;
        }
        self.time_zone_offset = Vec::with_capacity(v.len());
        for &x in v {
            let unscaled = (x + 0.0) * 4.0;
            if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i8::MAX as f64 {
                self.time_zone_offset.push(i8::MAX);
                continue;
            }
            self.time_zone_offset.push(unscaled as i8);
        }
        self
    }

    fn count_valid_fields(&self) -> usize {
        (self.active_time_zone != u8::MAX) as usize
            + (self.utc_offset != u32::MAX) as usize
            + (!self.time_offset.is_empty()) as usize
            + (!self.time_mode.is_empty()) as usize
            + (!self.time_zone_offset.is_empty()) as usize
            + (self.backlight_mode != typedef::BacklightMode(u8::MAX)) as usize
            + (self.activity_tracker_enabled != typedef::Bool(u8::MAX)) as usize
            + (self.clock_time != typedef::DateTime(u32::MAX)) as usize
            + (!self.pages_enabled.is_empty()) as usize
            + (self.move_alert_enabled != typedef::Bool(u8::MAX)) as usize
            + (self.date_mode != typedef::DateMode(u8::MAX)) as usize
            + (self.display_orientation != typedef::DisplayOrientation(u8::MAX)) as usize
            + (self.mounting_side != typedef::Side(u8::MAX)) as usize
            + (!self.default_page.is_empty()) as usize
            + (self.autosync_min_steps != u16::MAX) as usize
            + (self.autosync_min_time != u16::MAX) as usize
            + (self.lactate_threshold_autodetect_enabled != typedef::Bool(u8::MAX)) as usize
            + (self.ble_auto_upload_enabled != typedef::Bool(u8::MAX)) as usize
            + (self.auto_sync_frequency != typedef::AutoSyncFrequency(u8::MAX)) as usize
            + (self.auto_activity_detect != typedef::AutoActivityDetect(u32::MAX)) as usize
            + (self.number_of_screens != u8::MAX) as usize
            + (self.smart_notification_display_orientation != typedef::DisplayOrientation(u8::MAX))
                as usize
            + (self.tap_interface != typedef::Switch(u8::MAX)) as usize
            + (self.tap_sensitivity != typedef::TapSensitivity(u8::MAX)) as usize
    }
}

impl Default for DeviceSettings {
    fn default() -> Self {
        Self::new()
    }
}

impl From<&Message> for DeviceSettings {
    /// from creates new DeviceSettings struct based on given mesg.
    fn from(mesg: &Message) -> Self {
        const KNOWN_NUMS: [u64; 4] = [1117105531807338551, 3326148608, 70368744177728, 0];
        let mut n = 0u64;
        for field in &mesg.fields {
            n += (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 ^ 1
        }

        let mut v = Self::new();
        v.unknown_fields = Vec::<Field>::with_capacity(n as usize);
        v.developer_fields = mesg.developer_fields.clone();

        for field in &mesg.fields {
            match field.num {
                0 => v.active_time_zone = field.value.as_u8(),
                1 => v.utc_offset = field.value.as_u32(),
                2 => v.time_offset = field.value.to_vec_u32(),
                4 => {
                    v.time_mode = match &field.value {
                        Value::VecUint8(v) => {
                            let mut vs = Vec::with_capacity(v.len());
                            vs.extend(v.iter().map(|&x| typedef::TimeMode(x)));
                            vs
                        }
                        _ => Vec::new(),
                    }
                }
                5 => v.time_zone_offset = field.value.to_vec_i8(),
                12 => v.backlight_mode = typedef::BacklightMode(field.value.as_u8()),
                36 => v.activity_tracker_enabled = typedef::Bool(field.value.as_u8()),
                39 => v.clock_time = typedef::DateTime(field.value.as_u32()),
                40 => v.pages_enabled = field.value.to_vec_u16(),
                46 => v.move_alert_enabled = typedef::Bool(field.value.as_u8()),
                47 => v.date_mode = typedef::DateMode(field.value.as_u8()),
                55 => v.display_orientation = typedef::DisplayOrientation(field.value.as_u8()),
                56 => v.mounting_side = typedef::Side(field.value.as_u8()),
                57 => v.default_page = field.value.to_vec_u16(),
                58 => v.autosync_min_steps = field.value.as_u16(),
                59 => v.autosync_min_time = field.value.as_u16(),
                80 => v.lactate_threshold_autodetect_enabled = typedef::Bool(field.value.as_u8()),
                86 => v.ble_auto_upload_enabled = typedef::Bool(field.value.as_u8()),
                89 => v.auto_sync_frequency = typedef::AutoSyncFrequency(field.value.as_u8()),
                90 => v.auto_activity_detect = typedef::AutoActivityDetect(field.value.as_u32()),
                94 => v.number_of_screens = field.value.as_u8(),
                95 => {
                    v.smart_notification_display_orientation =
                        typedef::DisplayOrientation(field.value.as_u8())
                }
                134 => v.tap_interface = typedef::Switch(field.value.as_u8()),
                174 => v.tap_sensitivity = typedef::TapSensitivity(field.value.as_u8()),
                _ => v.unknown_fields.push(field.clone()),
            };
        }

        v
    }
}

impl From<DeviceSettings> for Message {
    fn from(m: DeviceSettings) -> Self {
        let mut fields =
            Vec::<Field>::with_capacity(m.count_valid_fields() + m.unknown_fields.len());

        if m.active_time_zone != u8::MAX {
            fields.push(Field {
                num: 0,
                profile_type: ProfileType::UINT8,
                value: Value::Uint8(m.active_time_zone),
                is_expanded: false,
            });
        };
        if m.utc_offset != u32::MAX {
            fields.push(Field {
                num: 1,
                profile_type: ProfileType::UINT32,
                value: Value::Uint32(m.utc_offset),
                is_expanded: false,
            });
        };
        if !m.time_offset.is_empty() {
            fields.push(Field {
                num: 2,
                profile_type: ProfileType::UINT32,
                value: Value::VecUint32(m.time_offset),
                is_expanded: false,
            });
        };
        if !m.time_mode.is_empty() {
            fields.push(Field {
                num: 4,
                profile_type: ProfileType::TIME_MODE,
                value: Value::VecUint8({
                    let (ptr, len, capacity) = m.time_mode.into_raw_parts();
                    unsafe { Vec::from_raw_parts(ptr.cast::<u8>(), len, capacity) }
                }),
                is_expanded: false,
            });
        };
        if !m.time_zone_offset.is_empty() {
            fields.push(Field {
                num: 5,
                profile_type: ProfileType::SINT8,
                value: Value::VecInt8(m.time_zone_offset),
                is_expanded: false,
            });
        };
        if m.backlight_mode != typedef::BacklightMode(u8::MAX) {
            fields.push(Field {
                num: 12,
                profile_type: ProfileType::BACKLIGHT_MODE,
                value: Value::Uint8(m.backlight_mode.0),
                is_expanded: false,
            });
        };
        if m.activity_tracker_enabled != typedef::Bool(u8::MAX) {
            fields.push(Field {
                num: 36,
                profile_type: ProfileType::BOOL,
                value: Value::Uint8(m.activity_tracker_enabled.0),
                is_expanded: false,
            });
        };
        if m.clock_time != typedef::DateTime(u32::MAX) {
            fields.push(Field {
                num: 39,
                profile_type: ProfileType::DATE_TIME,
                value: Value::Uint32(m.clock_time.0),
                is_expanded: false,
            });
        };
        if !m.pages_enabled.is_empty() {
            fields.push(Field {
                num: 40,
                profile_type: ProfileType::UINT16,
                value: Value::VecUint16(m.pages_enabled),
                is_expanded: false,
            });
        };
        if m.move_alert_enabled != typedef::Bool(u8::MAX) {
            fields.push(Field {
                num: 46,
                profile_type: ProfileType::BOOL,
                value: Value::Uint8(m.move_alert_enabled.0),
                is_expanded: false,
            });
        };
        if m.date_mode != typedef::DateMode(u8::MAX) {
            fields.push(Field {
                num: 47,
                profile_type: ProfileType::DATE_MODE,
                value: Value::Uint8(m.date_mode.0),
                is_expanded: false,
            });
        };
        if m.display_orientation != typedef::DisplayOrientation(u8::MAX) {
            fields.push(Field {
                num: 55,
                profile_type: ProfileType::DISPLAY_ORIENTATION,
                value: Value::Uint8(m.display_orientation.0),
                is_expanded: false,
            });
        };
        if m.mounting_side != typedef::Side(u8::MAX) {
            fields.push(Field {
                num: 56,
                profile_type: ProfileType::SIDE,
                value: Value::Uint8(m.mounting_side.0),
                is_expanded: false,
            });
        };
        if !m.default_page.is_empty() {
            fields.push(Field {
                num: 57,
                profile_type: ProfileType::UINT16,
                value: Value::VecUint16(m.default_page),
                is_expanded: false,
            });
        };
        if m.autosync_min_steps != u16::MAX {
            fields.push(Field {
                num: 58,
                profile_type: ProfileType::UINT16,
                value: Value::Uint16(m.autosync_min_steps),
                is_expanded: false,
            });
        };
        if m.autosync_min_time != u16::MAX {
            fields.push(Field {
                num: 59,
                profile_type: ProfileType::UINT16,
                value: Value::Uint16(m.autosync_min_time),
                is_expanded: false,
            });
        };
        if m.lactate_threshold_autodetect_enabled != typedef::Bool(u8::MAX) {
            fields.push(Field {
                num: 80,
                profile_type: ProfileType::BOOL,
                value: Value::Uint8(m.lactate_threshold_autodetect_enabled.0),
                is_expanded: false,
            });
        };
        if m.ble_auto_upload_enabled != typedef::Bool(u8::MAX) {
            fields.push(Field {
                num: 86,
                profile_type: ProfileType::BOOL,
                value: Value::Uint8(m.ble_auto_upload_enabled.0),
                is_expanded: false,
            });
        };
        if m.auto_sync_frequency != typedef::AutoSyncFrequency(u8::MAX) {
            fields.push(Field {
                num: 89,
                profile_type: ProfileType::AUTO_SYNC_FREQUENCY,
                value: Value::Uint8(m.auto_sync_frequency.0),
                is_expanded: false,
            });
        };
        if m.auto_activity_detect != typedef::AutoActivityDetect(u32::MAX) {
            fields.push(Field {
                num: 90,
                profile_type: ProfileType::AUTO_ACTIVITY_DETECT,
                value: Value::Uint32(m.auto_activity_detect.0),
                is_expanded: false,
            });
        };
        if m.number_of_screens != u8::MAX {
            fields.push(Field {
                num: 94,
                profile_type: ProfileType::UINT8,
                value: Value::Uint8(m.number_of_screens),
                is_expanded: false,
            });
        };
        if m.smart_notification_display_orientation != typedef::DisplayOrientation(u8::MAX) {
            fields.push(Field {
                num: 95,
                profile_type: ProfileType::DISPLAY_ORIENTATION,
                value: Value::Uint8(m.smart_notification_display_orientation.0),
                is_expanded: false,
            });
        };
        if m.tap_interface != typedef::Switch(u8::MAX) {
            fields.push(Field {
                num: 134,
                profile_type: ProfileType::SWITCH,
                value: Value::Uint8(m.tap_interface.0),
                is_expanded: false,
            });
        };
        if m.tap_sensitivity != typedef::TapSensitivity(u8::MAX) {
            fields.push(Field {
                num: 174,
                profile_type: ProfileType::TAP_SENSITIVITY,
                value: Value::Uint8(m.tap_sensitivity.0),
                is_expanded: false,
            });
        };

        fields.extend_from_slice(&m.unknown_fields);

        Self {
            header: 0,
            num: typedef::MesgNum::DEVICE_SETTINGS,
            fields,
            developer_fields: m.developer_fields,
        }
    }
}