ghost-eye/src/components/explorer/explorer_blocks.rs

use std::collections::{HashMap, VecDeque};
use color_eyre::Result;
use crossterm::event::{KeyCode, KeyEvent};
use primitive_types::H256;
use ratatui::{
    layout::{Alignment, Rect}, 
    prelude::*, 
    style::Style, 
    text::Line, 
    widgets::{Block, BorderType, Paragraph},
    Frame
};
use sp_core::crypto::{AccountId32, Ss58Codec, Ss58AddressFormat};
use codec::Decode;

use super::Component;
use crate::{
    types::CasperExtrinsicDetails, CasperAccountId,
    action::Action, app::Mode, palette::StylePalette,
};

struct BlockInfo {
    block_number: u32,
    finalized: bool,
}

#[derive(Default)]
pub struct ExplorerBlocks {
    blocks: VecDeque<BlockInfo>,
    block_headers: HashMap<u32, H256>,
    authors: HashMap<H256, CasperAccountId>,
    extrinsics: HashMap<H256, Vec<CasperExtrinsicDetails>>,
    palette: StylePalette,
    current_block_digit_length: u32,

    is_active: bool,
    used_paragraph_index: usize,
    used_block_number: Option<u32>,
    used_ext_index: Option<(H256, usize)>,
}

impl ExplorerBlocks {
    const MAX_BLOCKS:           usize = 50;
    const LENGTH_OF_BLOCK_HASH: u16   = 13;
    const LENGTH_OF_ADDRESS:    u16   = 49;
    const TOTAL_OFFSETS:        u16   = 18;

    fn update_block_author(
        &mut self, 
        hash: H256, 
        maybe_author: Option<CasperAccountId>,
    ) -> Result<()> {
        if let Some(author) = maybe_author {
            self.authors.insert(hash, author);
        }
        Ok(())
    }

    fn update_latest_block_info(
        &mut self, 
        hash: H256, 
        block_number: u32, 
        extrinsics: Vec<CasperExtrinsicDetails>,
    ) -> Result<()> {
        let front_block_number = match self.blocks.front() {
            Some(block_info) => block_info.block_number,
            None => 0,
        };

        if front_block_number < block_number {
            self.blocks.push_front(BlockInfo {
                block_number, 
                finalized: false,
            });

            self.extrinsics.insert(hash, extrinsics);
            self.block_headers.insert(block_number, hash);

            let block_length = block_number.checked_ilog10().unwrap_or(0) + 1;
            if self.current_block_digit_length < block_length {
                self.current_block_digit_length = block_length;
            }

            if self.blocks.len() > Self::MAX_BLOCKS {
                if let Some(block) = self.blocks.pop_back() {
                    if let Some(hash) = self.block_headers.remove(&block.block_number) {
                        self.extrinsics.remove(&hash);
                        self.authors.remove(&hash);
                    }
                }
            }
        }
        Ok(())
    }

    fn update_finalized_block_info(
        &mut self, 
        _hash: H256, 
        block_number: u32, 
        _extrinsics: Vec<CasperExtrinsicDetails>,
    ) -> Result<()> {
        for idx in 0..self.blocks.len() {
            if self.blocks[idx].finalized { break; }
            else if self.blocks[idx].block_number > block_number { continue; }
            else { self.blocks[idx].finalized = true; }
        }

        Ok(())
    }

    fn prepare_block_line_info(&self, current_block: &BlockInfo, width: u16) -> Line {
        let block_number_length = self
            .current_block_digit_length
            .max(current_block.block_number.checked_ilog10().unwrap_or(0) + 1) as usize;

        let free_space = width
            .saturating_sub(block_number_length as u16)
            .saturating_sub(Self::TOTAL_OFFSETS);

        let default_hash = H256::repeat_byte(69u8);
        let hash = self
            .block_headers
            .get(&current_block.block_number)
            .unwrap_or(&default_hash);

        let author = self
            .authors
            .get(&hash)
            .map_or(String::from("..."), |author| {
                let extended_author = AccountId32::decode(&mut author.as_ref())
                    .expect("author should be valid AccountId32; qed");
                extended_author.to_ss58check_with_version(Ss58AddressFormat::custom(1996))
            });

        if free_space < Self::LENGTH_OF_BLOCK_HASH + Self::LENGTH_OF_ADDRESS {
            let len_for_author = free_space * Self::LENGTH_OF_ADDRESS / (Self::LENGTH_OF_BLOCK_HASH + Self::LENGTH_OF_ADDRESS);

            if &author == "..." {
                Line::raw(format!("{:^left$}| {} | {:^right$}", 
                        current_block.block_number, 
                        hash.to_string(),
                        author,
                        left=block_number_length,
                        right=(len_for_author + 2) as usize))
            } else {
                Line::raw(format!("{} | {} | {}", 
                        current_block.block_number, 
                        hash.to_string(),
                        format!("{}...", &author[..(len_for_author) as usize])))
            }
        } else {
            let total_space_used = block_number_length as u16 + Self::LENGTH_OF_BLOCK_HASH + Self::LENGTH_OF_ADDRESS;
            let str_length = width.saturating_sub(2).saturating_sub(total_space_used) as usize / 3;
            Line::raw(format!("{:^length_block_number$}|{:^length_hash$}|{:^length_author$}",
                    current_block.block_number, hash.to_string(), author,
                    length_block_number=str_length+block_number_length,
                    length_hash=str_length+(Self::LENGTH_OF_BLOCK_HASH as usize),
                    length_author=str_length+(Self::LENGTH_OF_ADDRESS as usize)))
        }
    }

    fn prepare_block_lines(&mut self, rect: Rect) -> Vec<Line> {
        let width = rect.as_size().width;
        let total_length = rect.as_size().height as usize - 2;
        let mut items = Vec::new();

        let active_style = self.palette.create_text_style(true);
        let latest_style = self.palette.create_text_style(false);
        let finalized_style = Style::new().fg(self.palette.foreground_hover());

        let start_index = match self.used_block_number {
            Some(used_block) if total_length < self.blocks.len() => {
                self.blocks
                    .iter()
                    .position(|info| info.block_number == used_block)
                    .unwrap_or_default()
                    .saturating_add(1)
                    .saturating_sub(total_length)
            },
            _ => 0,
        };

        for (idx, current_block_info) in self.blocks.iter().skip(start_index).enumerate() {
            if idx == total_length { break; }

            let style = match self.used_block_number {
                Some(used_block) if current_block_info.block_number == used_block => active_style,
                _ => {
                    if current_block_info.finalized { finalized_style } else { latest_style }
                }
            };

            items.push(self.prepare_block_line_info(&current_block_info, width).style(style));
        }

        items
    }

    fn prepare_ext_line_info(
        &self, 
        index: usize,
        width: u16,
        pallet_name: &str,
        variant_name: &str,
        hash: &str,
    ) -> Line {
        let index_length = 4; // always 4, two digits and two spaces
        let hash_length = Self::LENGTH_OF_BLOCK_HASH as usize + 2;
        let pallet_name_length = pallet_name.len();
        let variant_name_length = variant_name.len();

        let offset_variant = (width as usize)
            .saturating_sub(index_length)
            .saturating_sub(pallet_name_length)
            .saturating_sub(variant_name_length)
            .saturating_sub(hash_length)
            .saturating_sub(2) / 2;

        let offset_pallet = if offset_variant % 2 == 0 {
            offset_variant
        } else {
            offset_variant + 1
        };

        Line::from(format!("{:^index_length$}{:>pallet_name_offset$}::{:<variant_name_offset$}{:^hash_length$}", 
                index, pallet_name, variant_name, hash,
                pallet_name_offset=offset_pallet+pallet_name_length,
                variant_name_offset=offset_variant+variant_name_length))
    }

    fn prepare_ext_lines(&mut self, rect: Rect) -> Vec<Line> {
        let width = rect.as_size().width;
        let mut total_length = rect.as_size().height - 2;
        let mut items = Vec::new();

        let normal_style = self.palette.create_text_style(false);
        let active_style = self.palette.create_text_style(true);

        if let Some(used_block_number) = self.used_block_number {
            let default_hash = H256::repeat_byte(69u8);
            let hash = self.block_headers
                .get(&used_block_number)
                .unwrap_or(&default_hash);

            if let Some(exts) = self.extrinsics.get(&hash) {
                for (index, ext) in exts.iter().enumerate() {
                    if total_length == 0 { break; }

                    let style = if let Some((_, used_ext_index)) = self.used_ext_index {
                        if index == used_ext_index { active_style } else { normal_style }
                    } else {
                        normal_style
                    };

                    items.push(self.prepare_ext_line_info(
                            index, 
                            width.saturating_sub(2),
                            &ext.pallet_name, 
                            &ext.variant_name, 
                            &ext.hash.to_string()).style(style));
                    total_length -= 1;
                }
            }
        }

        items
    }

    fn prepare_event_lines(&mut self, rect: Rect) -> Line {
        let _width = rect.as_size().width;

        match self.used_ext_index {
            Some((header, used_index)) if self.extrinsics.get(&header).is_some() => {
                let exts = self.extrinsics
                    .get(&header)
                    .expect("extrinsics should exists, checked before");

                let details = exts
                    .get(used_index)
                    .map_or(Vec::new(), |ext| ext.field_bytes.clone());

                Line::from(format!("{}", hex::encode(&details)))
            },
            _ => Line::from(""),
        }.style(self.palette.create_text_style(false))
    }

    fn move_right(&mut self) {
        let new_index = self.used_paragraph_index + 1;
        if new_index < 2 {
            self.used_paragraph_index = new_index;
        }
    }
    
    fn move_left(&mut self) {
        self.used_paragraph_index = self
            .used_paragraph_index
            .saturating_sub(1);
        self.used_ext_index = None;
    }

    fn move_down(&mut self) {
        if self.used_paragraph_index == 0 {
            self.move_down_blocks();
        } else {
            self.move_down_extrinsics();
        }
    }

    fn move_up(&mut self) {
        if self.used_paragraph_index == 0 {
            self.move_up_blocks();
        } else {
            self.move_up_extrinsics();
        }
    }

    fn move_up_extrinsics(&mut self) {
        match &self.used_ext_index {
            Some((header, used_index)) => {
                let new_index = used_index.saturating_sub(1);
                if let Some(exts) = self.extrinsics.get(header) {
                    if exts.get(new_index).is_some() {
                        self.used_ext_index = Some((*header, new_index));
                    }
                }
            },
            None => {
                self.used_ext_index = self.used_block_number
                    .map(|block_number| {
                        let header = self.block_headers
                            .get(&block_number)
                            .expect("header exists for each block number; qed");
                        self.extrinsics.get(&header).map(|_| (*header, 0usize))
                    })
                    .flatten()
            }
        }
    }

    fn move_up_blocks(&mut self) {
        self.used_block_number = match &self.used_block_number {
            Some(block_number) => {
                Some(self.blocks
                    .iter()
                    .find(|info| info.block_number == block_number + 1)
                    .map(|info| info.block_number)
                    .unwrap_or(*block_number))
            },
            None => self.blocks.front().map(|info| info.block_number),
        }
    }

    fn move_down_extrinsics(&mut self) {
        match &self.used_ext_index {
            Some((header, used_index)) => {
                let new_index = used_index + 1;
                if let Some(exts) = self.extrinsics.get(&header) {
                    if new_index < exts.len() && exts.get(new_index).is_some() {
                        self.used_ext_index = Some((*header, new_index));
                    }
                }
            },
            None => {
                self.used_ext_index = self.used_block_number
                    .map(|block_number| {
                        let header = self.block_headers
                            .get(&block_number)
                            .expect("header exists for each block number; qed");
                        self.extrinsics.get(&header).map(|_| (*header, 0usize))
                    })
                    .flatten()
            }
        }
    }

    fn move_down_blocks(&mut self) {
        self.used_block_number = match &self.used_block_number {
            Some(block_number) => {
                Some(self.blocks
                    .iter()
                    .find(|info| info.block_number == block_number.saturating_sub(1))
                    .map(|info| info.block_number)
                    .unwrap_or(*block_number))
            },
            None => {
                self.blocks.front().map(|info| info.block_number)
            }
        }
    }

    fn set_active(&mut self) -> Result<()> {
        self.is_active = true;
        Ok(())
    }

    fn unset_active(&mut self) -> Result<()> {
        self.is_active = false;
        Ok(())
    }

    fn prepare_blocks_paragraph(
        &mut self, 
        place: Rect, 
        border_style: Color,
        border_type: BorderType,
    ) -> Paragraph {
        let title_style = self.palette.create_title_style();
        Paragraph::new(self.prepare_block_lines(place))
            .block(Block::bordered()
                .border_style(border_style)
                .border_type(border_type)
                .title_alignment(Alignment::Right)
                .title_style(title_style)
                .title("Blocks"))
            .alignment(Alignment::Center)
    }

    fn prepare_extrinsics_paragraph(
        &mut self, 
        place: Rect, 
        border_style: Color,
        border_type: BorderType,
    ) -> Paragraph {
        let title_style = self.palette.create_title_style();
        Paragraph::new(self.prepare_ext_lines(place))
            .block(Block::bordered()
                .border_style(border_style)
                .border_type(border_type)
                .title_alignment(Alignment::Right)
                .title_style(title_style)
                .title("Transactions"))
            .alignment(Alignment::Center)
    }

    fn prepare_event_paragraph(
        &mut self, 
        place: Rect, 
        border_style: Color,
        border_type: BorderType,
    ) -> Paragraph {
        let title_style = self.palette.create_title_style();
        Paragraph::new(self.prepare_event_lines(place))
            .block(Block::bordered()
                .border_style(border_style)
                .border_type(border_type)
                .title_alignment(Alignment::Right)
                .title_style(title_style)
                .title("Events"))
            .alignment(Alignment::Center)
    }
}

impl Component for ExplorerBlocks {
    fn handle_key_event(&mut self, key: KeyEvent) -> Result<Option<Action>> {
        match key.code {
            KeyCode::Char('k') | KeyCode::Up if self.is_active => self.move_up(), 
            KeyCode::Char('j') | KeyCode::Down if self.is_active => self.move_down(), 
            KeyCode::Char('l') | KeyCode::Right if self.is_active => self.move_right(), 
            KeyCode::Char('h') | KeyCode::Left if self.is_active => self.move_left(), 
            KeyCode::Esc => {
                self.used_block_number = None;
                self.used_ext_index = None;
                self.used_paragraph_index = 0;
            }, 
            _ => {},
        };

        Ok(None)
    }

    fn update(&mut self, action: Action) -> Result<Option<Action>> {
        match action {
            Action::BestBlockInformation(hash, block_number, extrinsics) => self.update_latest_block_info(hash, block_number, extrinsics)?,
            Action::FinalizedBlockInformation(hash, block_number, extrinsics) => self.update_finalized_block_info(hash, block_number, extrinsics)?,
            Action::SetBlockAuthor(hash, maybe_author) => self.update_block_author(hash, maybe_author)?,
            Action::SetMode(Mode::ExplorerActive) if !self.is_active => self.set_active()?,
            Action::SetMode(_) if self.is_active => self.unset_active()?,
            _ => {}
        };
        Ok(None)
    }

    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
        let [blocks_place, ext_place] = super::explorer_scrollbars_layout(area);
        let [_, _, event_place] = super::explorer_layout(area);

        let (border_style_block, border_type_block) = self.palette.create_border_style(self.is_active && self.used_paragraph_index == 0);
        let (border_style_extrinsics, border_type_extrinsics) = self.palette.create_border_style(self.is_active && self.used_paragraph_index == 1);
        // TODO: never used, revisit
        let (border_style_event, border_type_event) = self.palette.create_border_style(self.is_active && self.used_paragraph_index == 2);

        frame.render_widget(self.prepare_blocks_paragraph(blocks_place, border_style_block, border_type_block), blocks_place);
        frame.render_widget(self.prepare_extrinsics_paragraph(ext_place, border_style_extrinsics, border_type_extrinsics), ext_place);
        frame.render_widget(self.prepare_event_paragraph(event_place, border_style_event, border_type_event), event_place);
        Ok(())
    }
}