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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

pub mod controller;
pub mod ze00;
pub mod ze30;
pub mod ze60;

pub enum Controller<'a> {
    Ze00(ze00::Controller<'a>),
    Ze30(ze30::Controller<'a>),
    Ze60(ze60::Controller<'a>),
    Default(controller::Controller<'a>),
}

#[derive(Debug, thiserror::Error)]
pub enum ControlError {
    #[error("Expected zenith angle 0, 30 or 60 found {0}")]
    ZenithAngle(i32),
}

type Result<T> = std::result::Result<T, ControlError>;

impl<'a> Controller<'a> {
    /// Returns a default mount controller
    pub fn new() -> Self {
        Controller::Default(controller::Controller::new())
    }
    /// Returns a mount controller for the given zenith angle
    ///
    /// The zenith angle is either 0, 30 or 60 degrees
    pub fn at_zenith_angle(ze: i32) -> Result<Self> {
        match ze {
            ze if ze == 0 => Ok(Self::Ze00(ze00::Controller::new())),
            ze if ze == 30 => Ok(Self::Ze30(ze30::Controller::new())),
            ze if ze == 60 => Ok(Self::Ze60(ze60::Controller::new())),
            _ => Err(ControlError::ZenithAngle(ze)),
        }
    }
    /// Returns a mount controller for the given elevation
    ///
    /// The elevation is either 90, 60 or 30 degrees
    pub fn at_elevation(el: i32) -> Result<Self> {
        Self::at_zenith_angle(90 - el)
    }
    pub fn mount_fb(&mut self) -> Option<&mut [f64; 14]> {
        match self {
            Controller::Ze00(controller) => {
                if let ze00::U::MountFB(val) = &mut controller.mount_fb {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Ze30(controller) => {
                if let ze30::U::MountFB(val) = &mut controller.mount_fb {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Ze60(controller) => {
                if let ze60::U::MountFB(val) = &mut controller.mount_fb {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Default(controller) => {
                if let controller::U::MountFB(val) = &mut controller.mount_fb {
                    Some(val)
                } else {
                    None
                }
            }
        }
    }
    pub fn mount_sp(&mut self) -> Option<&mut [f64; 3]> {
        match self {
            Controller::Ze00(controller) => {
                if let ze00::U::MountSP(val) = &mut controller.mount_sp {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Ze30(controller) => {
                if let ze30::U::MountSP(val) = &mut controller.mount_sp {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Ze60(controller) => {
                if let ze60::U::MountSP(val) = &mut controller.mount_sp {
                    Some(val)
                } else {
                    None
                }
            }
            Controller::Default(controller) => {
                if let controller::U::MountSP(val) = &mut controller.mount_sp {
                    Some(val)
                } else {
                    None
                }
            }
        }
    }
    pub fn mount_cmd(&mut self) -> Option<&[f64; 3]> {
        match self {
            Controller::Ze00(controller) => {
                let ze00::Y::Mountcmd(val) = &controller.mount_cmd;
                Some(val)
            }
            Controller::Ze30(controller) => {
                let ze30::Y::Mountcmd(val) = &controller.mount_cmd;
                Some(val)
            }
            Controller::Ze60(controller) => {
                let ze60::Y::Mountcmd(val) = &controller.mount_cmd;
                Some(val)
            }
            Controller::Default(controller) => {
                let controller::Y::Mountcmd(val) = &controller.mount_cmd;
                Some(val)
            }
        }
    }
}

impl<'a> Iterator for Controller<'a> {
    type Item = ();

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Controller::Ze00(control) => control.next(),
            Controller::Ze30(control) => control.next(),
            Controller::Ze60(control) => control.next(),
            Controller::Default(control) => control.next(),
        }
    }
}