#[allow(dead_code)]
pub struct Storage {
    // TODO: add custom timestamp class which can be queried by
    // beats/measures/etc.
    pub timestamp: u64,
    pub playback_mode: PlaybackMode,
    pub bpm_changes: Vec<BpmChange>,
    pub time_changes: Vec<TimeChange>,
    pub keyframe_channels: Vec<KeyframeChannel>
}

pub enum PlaybackMode {
    Playing,
    Stopped,
    Paused
}

pub struct BpmChange {
    pub timestamp: u64,
    pub bpm: u32
}

pub struct TimeChange {
    pub timestamp: u64,
    pub time: (u8, u8)
}

pub struct KeyframeChannel {
    pub name: String,
    pub enabled: bool,
    pub keyframes: Vec<Keyframe>
}

pub enum KeyframeType {
    Tick
}

pub struct Keyframe {
    pub kf_type: KeyframeType,
    pub timestamp: u64
}

impl Storage {
    pub fn init() -> Storage {
        Storage {
            timestamp: 0,
            playback_mode: PlaybackMode::Stopped,
            bpm_changes: Vec::<BpmChange>::new(),
            time_changes: Vec::<TimeChange>::new(),
            keyframe_channels: Vec::<KeyframeChannel>::new()
        }
    }

    pub fn add_bpm_change(&mut self, timestamp: u64, bpm: u32) {
        self.bpm_changes.push(BpmChange::new(timestamp, bpm));
    }

    pub fn delete_last_bpm_change(&mut self) {
        self.bpm_changes.pop();
    }

    pub fn get_bpm_change_index(&self, timestamp: u64) -> Option<usize> {
        for (idx, bc) in self.bpm_changes.iter().enumerate() {
            if (bc.timestamp) == timestamp {
                return Some(idx);
            }
        }
        None
    }

    pub fn initial_bpm(&self) -> u32 {
        self.bpm_changes[0].bpm
    }
    
    pub fn add_time_change(&mut self, timestamp: u64, time: (u8, u8)) {
        self.time_changes.push(TimeChange::new(timestamp, time));
    }

    pub fn add_keyframe_channel(&mut self, name: String) {
        self.keyframe_channels.push(KeyframeChannel::new(name));
    }

    pub fn keyframe_channel_by_name(
        &self,
        name: String
    ) -> Option<&KeyframeChannel> {
        for chan in self.keyframe_channels.iter() {
            if chan.name == name {
                return Some(chan);
            }
        }
        None
    }
}

impl BpmChange {
    pub fn new(timestamp: u64, bpm: u32) -> BpmChange {
        BpmChange { timestamp, bpm }
    }
}

impl TimeChange {
    pub fn new(timestamp: u64, time: (u8, u8)) -> TimeChange {
        TimeChange { timestamp, time }
    }
}

impl KeyframeChannel {
    pub fn new(name: String) -> KeyframeChannel {
        KeyframeChannel {
            name,
            enabled: true,
            keyframes: Vec::<Keyframe>::new()
        }
    }

    pub fn add_keyframe(&mut self, timestamp: u64) {
        self.keyframes.push(Keyframe {
            kf_type: KeyframeType::Tick,
            timestamp
        });
    }
    
    // TODO: improve efficiency of this method
    pub fn keyframe_at_timestamp(&self, timestamp: u64) -> Option<&Keyframe> {
        for keyframe in self.keyframes.iter() {
            if keyframe.timestamp == timestamp {
                return Some(keyframe);
            }
        }
        None
    }
}