ntdsextract2 1.4.31

use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread::spawn;

use cursive::view::{Nameable, Resizable, Scrollable};
use cursive::views::{LinearLayout, NamedView, ResizedView, ScrollView};
use cursive::views::{Panel, TextView};
use cursive::Cursive;
use cursive_logger_view::{CursiveLogWriter, FlexiLoggerView};
use cursive_table_view::{TableColumn, TableView};
use cursive_tabs::TabPanel;
use cursive_tree_view::Placement;
use cursive_tree_view::TreeView;
use flexi_logger::Logger;
use libntdsextract2::ntds::TransitiveClosure;
use libntdsextract2::{CDatabase, EntryId, ObjectTreeEntry};

mod acl_column;
mod acl_line;
mod attribute_column;
mod attribute_line;
mod attribute_line_set;
mod entry_attributes;
mod membership_tree_entry;
mod tree_entry;

use attribute_column::*;
use attribute_line::*;
use entry_attributes::*;
use tree_entry::*;

use crate::walk::acl_column::AclColumn;
use crate::walk::acl_line::AclLine;
use crate::walk::membership_tree_entry::MembershipTreeEntry;

const TREE: &str = "tree_view";
const ATTRIBUTES: &str = "(A)ttributes";
const ACL: &str = "Access (C)ontrol List";
const MEMBERSHIPS: &str = "(M)emberships";
const MEMBERS: &str = "Members";
const MEMBEROF: &str = "Member of";
const MEMBERS_PANEL: &str = "MembersPanel";
const MEMBEROF_PANEL: &str = "MemberOfPanel";
const SACL: &str = "SACL";
const DACL: &str = "DACL";
const LEFT_PANEL: &str = "left_panel";
const RIGHT_PANEL: &str = "right_panel";
const LAYOUT: &str = "layout";
const LOG_VIEW: &str = "log_view";
const TABS: &str = "Tabs";
const USER: &str = "User";
const GROUP: &str = "Group";

pub fn run_tui<'db, 'info>(database: CDatabase<'db, 'info>) -> anyhow::Result<()> {
    let mut tree_view = TreeView::new();
    insert_item(&mut tree_view, Arc::clone(database.object_tree().root()), 0);

    // because CDatabase is neither Send nor Sync, we leave it in the current
    // thread and move all the UI stuff to other threads
    let (tx_entry_id, rx_entry_id) = channel();
    let (tx_attribs, rx_attribs) = channel();
    let ui_thread = spawn(move || {
        ui_thread_fn(
            tree_view,
            Arc::new(Mutex::new(tx_entry_id)),
            Arc::new(Mutex::new(rx_attribs)),
        )
    });

    // from this point on, the current threads work as a data provider server
    // for the ui thread
    loop {
        match rx_entry_id.recv() {
            Ok(entry_id) => {
                let attributes = EntryAttributes::new(&database, entry_id);

                if tx_attribs.send(attributes).is_err() {
                    drop(rx_entry_id);
                    break;
                }
            }
            Err(_) => {
                drop(tx_attribs);
                break;
            }
        }
    }
    let _ = ui_thread.join();
    Ok(())
}

fn insert_item(tree_view: &mut TreeView<TreeEntry>, item: Arc<ObjectTreeEntry>, row: usize) {
    if item.children().lock().unwrap().is_empty() {
        tree_view.insert_item(TreeEntry::from(item), Placement::LastChild, row);
    } else {
        let row = tree_view
            .insert_container_item(
                TreeEntry::from(Arc::clone(&item)),
                Placement::LastChild,
                row,
            )
            .unwrap_or(0);
        // inserting elements in collapsed containers does not work
        tree_view.set_collapsed(row, false);
        let children = item.children().lock().unwrap();
        let mut sorted_children: Vec<_> = children.iter().collect();
        sorted_children.sort();
        for child in sorted_children {
            insert_item(tree_view, Arc::clone(child), row);
        }
        tree_view.set_collapsed(row, true);
    }
}

fn insert_membership(
    tree_view: &mut TreeView<MembershipTreeEntry>,
    mapping_table: TransitiveClosure<MembershipTreeEntry>,
    row: usize,
    placement: Placement,
) {
    let (value, children) = mapping_table.explode();
    if children.is_empty() {
        tree_view.insert_item(value, placement, row);
    } else {
        let row = tree_view
            .insert_container_item(value, placement, row)
            .unwrap_or(0);
        tree_view.set_collapsed(row, false);
        for child in children {
            insert_membership(tree_view, child, row, Placement::LastChild);
        }
    }
}

fn ui_thread_fn(
    mut tree_view: TreeView<TreeEntry>,
    tx_entry_id: Arc<Mutex<Sender<EntryId>>>,
    rx_attribs: Arc<Mutex<Receiver<EntryAttributes>>>,
) {
    let mut siv = cursive::default();

    siv.add_global_callback('q', |s| s.quit());
    siv.add_global_callback('+', enlarge_tree);
    siv.add_global_callback('-', shrink_tree);

    Logger::try_with_env_or_str("warn")
        .expect("Could not create Logger from environment :(")
        // Configure logging to both file and Cursive
        .log_to_writer(
            // Create Cursive log writer and box it for dynamic dispatch
            CursiveLogWriter::new(&siv)
                //// Optional format configuration (commented out example)
                // .with_format({
                //     use cursive_logger_view::LogItems::*;
                //     [Level, DateTime, ModLine, Message]
                //         .into_iter()
                //         .collect()
                // })
                // .with_time_format("%T%.6f".into())
                .into_boxed(),
        )
        .start()
        .unwrap();

    let attributes: TableView<AttributeLine, AttributeColumn> = TableView::new()
        .column(AttributeColumn::Name, "Name", |c| {
            c.align(cursive::align::HAlign::Left).width(33)
        })
        .column(AttributeColumn::Value, "Value", |c| {
            c.align(cursive::align::HAlign::Left)
        })
        .default_column(AttributeColumn::Name);

    let flag_column = |c: TableColumn<AclColumn>| c.width(2);
    fn left_column(width: usize) -> impl Fn(TableColumn<AclColumn>) -> TableColumn<AclColumn> {
        move |c: TableColumn<AclColumn>| c.align(cursive::align::HAlign::Left).width(width)
    }

    let ownership = Panel::new(
        LinearLayout::horizontal()
            .child(LinearLayout::horizontal().child(TextView::new("User: ")).child(TextView::new("").with_name(USER).full_width()))
            .child(LinearLayout::horizontal().child(TextView::new("Group: ")).child(TextView::new("").with_name(GROUP).full_width()))
            .fixed_height(1)
            .full_width(),
    )
    .title("Ownership")
    .full_width();

    let dacls: TableView<AclLine, AclColumn> = TableView::new()
        .column(AclColumn::ContainerInherit, "CI", flag_column)
        .column(AclColumn::ObjectInherit, "OI", flag_column)
        .column(AclColumn::NoPropagate, "NP", flag_column)
        .column(AclColumn::InheritOnly, "IO", flag_column)
        .column(AclColumn::Inherited, "ID", flag_column)
        .column(AclColumn::SubjectName, "Subject", left_column(46))
        .column(AclColumn::Operation, "Operation", left_column(10))
        .column(AclColumn::AccessMask, "AccessMask", left_column(40))
        .column(AclColumn::ExtendedRight, "Extended Right", |c| {
            c.align(cursive::align::HAlign::Left)
        });

    let sacls: TableView<AclLine, AclColumn> = TableView::new()
        .column(AclColumn::ContainerInherit, "CI", flag_column)
        .column(AclColumn::ObjectInherit, "OI", flag_column)
        .column(AclColumn::NoPropagate, "NP", flag_column)
        .column(AclColumn::InheritOnly, "IO", flag_column)
        .column(AclColumn::Inherited, "ID", flag_column)
        .column(AclColumn::SubjectName, "Subject", left_column(46))
        .column(AclColumn::Operation, "Operation", left_column(10))
        .column(AclColumn::AccessMask, "AccessMask", left_column(40))
        .column(AclColumn::ExtendedRight, "Extended Right", |c| {
            c.align(cursive::align::HAlign::Left)
        });
    const ACL_FLAGS_HELP: [(&str, &str); 20] = [
        ("GR", "Generic Read"),
        ("GW", "Generic Write"),
        ("GX", "Generic Execute"),
        ("GA", "Generic All"),
        ("MA", "Maximum Allowed"),
        ("AS", "Access System Security"),
        ("SY", "Synchronize"),
        ("WO", "Write Owner"),
        ("WD", "Write DACL"),
        ("RC", "Read Control"),
        ("SD", "Standard Delete"),
        ("CR", "Control Access"),
        ("LO", "List Object"),
        ("DT", "Delete Tree"),
        ("WP", "Write Property"),
        ("RP", "Read Property"),
        ("SW", "Self Write"),
        ("LC", "List Children"),
        ("DC", "Delete Child"),
        ("CC", "Create Child"),
    ];
    const ACL_FLAGS_COLUMNS: usize = 4;
    let mut acl_info_text = String::new();
    for (index, (short, long)) in ACL_FLAGS_HELP.into_iter().enumerate() {
        acl_info_text.push_str(&format!("{short} ... {long:25}"));
        if index % ACL_FLAGS_COLUMNS == ACL_FLAGS_COLUMNS - 1 {
            acl_info_text.push('\n');
        }
    }
    let acl_info = TextView::new(acl_info_text);

    let tx_entry_id_on_select = Arc::clone(&tx_entry_id);
    let rx_attribs_on_select = Arc::clone(&rx_attribs);
    tree_view.set_on_select(move |siv, row| {
        let tx_entry_id = Arc::clone(&tx_entry_id_on_select);
        let rx_attribs = Arc::clone(&rx_attribs_on_select);
        on_select(siv, row, tx_entry_id, rx_attribs)
    });

    let acl = LinearLayout::vertical()
        .child(ownership)
        .child(
            Panel::new(dacls.with_name(DACL))
                .title("Discretionary ACL")
                .full_screen(),
        )
        .child(
            Panel::new(sacls.with_name(SACL))
                .title("System ACL")
                .full_screen(),
        )
        .child(
            Panel::new(acl_info.fixed_height(ACL_FLAGS_HELP.len() / ACL_FLAGS_COLUMNS))
                .title("SDDL abbreviations for access mask flags"),
        );

    let memberships = LinearLayout::vertical()
        .child(
            Panel::new(TreeView::<MembershipTreeEntry>::new().with_name(MEMBERS))
                .title("Members")
                .with_name(MEMBERS_PANEL)
                .full_screen(),
        )
        .child(
            Panel::new(TreeView::<MembershipTreeEntry>::new().with_name(MEMBEROF))
                .title("is member of")
                .with_name(MEMBEROF_PANEL)
                .full_screen(),
        );

    let mut tab_panel = TabPanel::new()
        .with_tab(attributes.with_name(ATTRIBUTES))
        .with_tab(acl.with_name(ACL))
        .with_tab(memberships.with_name(MEMBERSHIPS));
    tab_panel.set_active_tab(ATTRIBUTES).unwrap();

    siv.add_global_callback('a', |siv| set_active_tab(siv, ATTRIBUTES));
    siv.add_global_callback('A', |siv| set_active_tab(siv, ATTRIBUTES));

    siv.add_global_callback('c', |siv| set_active_tab(siv, ACL));
    siv.add_global_callback('C', |siv| set_active_tab(siv, ACL));

    siv.add_global_callback('m', |siv| set_active_tab(siv, MEMBERSHIPS));
    siv.add_global_callback('M', |siv| set_active_tab(siv, MEMBERSHIPS));

    let tree_view_width = 60;
    let ntds_view = LinearLayout::horizontal()
        .child(
            Panel::new(tree_view.with_name(TREE).scrollable())
                .fixed_width(tree_view_width)
                .with_name(LEFT_PANEL),
        )
        .child(
            tab_panel
                .with_name(TABS)
                .full_screen()
                .with_name(RIGHT_PANEL),
        )
        .with_name(LAYOUT)
        .full_screen();
    let data_and_logview = LinearLayout::vertical()
        .child(ntds_view)
        .child(
            Panel::new(
                FlexiLoggerView::new()
                    .wrap_scroll_view()
                    .with_name(LOG_VIEW)
                    .fixed_height(10),
            )
            .title("Error log")
            .title_position(cursive::align::HAlign::Left),
        )
        .full_screen();
    siv.set_user_data(tree_view_width);

    siv.add_layer(data_and_logview);

    // initially select the first item
    on_select(
        &mut siv,
        0,
        Arc::clone(&tx_entry_id),
        Arc::clone(&rx_attribs),
    );
    siv.run();
    if let Ok(tx) = tx_entry_id.lock() {
        drop(tx)
    }
    if let Ok(rx) = rx_attribs.lock() {
        drop(rx)
    }
}

fn on_select(
    siv: &mut Cursive,
    row: usize,
    tx_entry_id: Arc<Mutex<Sender<EntryId>>>,
    rx_attribs: Arc<Mutex<Receiver<EntryAttributes>>>,
) {
    let tree_view = siv.find_name::<TreeView<TreeEntry>>(TREE).unwrap();
    if let Some(entry) = tree_view.borrow_item(row) {
        match tx_entry_id.lock() {
            Ok(tx) => {
                if tx
                    .send(EntryId::Id(*entry.entry().record_ptr().ds_record_id()))
                    .is_err()
                {
                    log::error!("unable to send record ID");
                    siv.quit();
                    return;
                }
            }
            _ => {
                log::error!("unable to acquire sender lock");
                siv.quit();
                return;
            }
        }

        match rx_attribs.lock() {
            Ok(rx) => match rx.recv() {
                Ok(mut entry_attributes) => {
                    let attribs = entry_attributes
                        .attributes
                        .into_iter()
                        .flat_map(|s| s.into_lines())
                        .collect();

                    let mut attributes_table = siv
                        .find_name::<TableView<AttributeLine, AttributeColumn>>(ATTRIBUTES)
                        .unwrap();
                    attributes_table.set_items(attribs);
                    attributes_table.set_selected_row(0);

                    if let Some(user) = entry_attributes.owner {
                        let mut user_txt = siv.find_name::<TextView>(USER).unwrap();
                        user_txt.set_content(user);
                    }
                    if let Some(group) = entry_attributes.group {
                        let mut group_txt = siv.find_name::<TextView>(GROUP).unwrap();
                        group_txt.set_content(group);
                    }

                    let mut acl_table = siv
                        .find_name::<TableView<AclLine, AclColumn>>(DACL)
                        .unwrap();
                    acl_table.set_items(entry_attributes.dacls);
                    acl_table.set_selected_row(0);

                    let mut acl_table = siv
                        .find_name::<TableView<AclLine, AclColumn>>(SACL)
                        .unwrap();
                    acl_table.set_items(entry_attributes.sacls);
                    acl_table.set_selected_row(0);

                    let mut members_tree = siv
                        .find_name::<TreeView<MembershipTreeEntry>>(MEMBERS)
                        .unwrap();
                    members_tree.clear();
                    if let Some(members) = entry_attributes.members.take() {
                        let (_, children) = members.explode();
                        for child in children {
                            insert_membership(&mut members_tree, child, 0, Placement::After);
                        }
                    }

                    let mut member_of_tree = siv
                        .find_name::<TreeView<MembershipTreeEntry>>(MEMBEROF)
                        .unwrap();
                    member_of_tree.clear();
                    if let Some(members) = entry_attributes.member_of.take() {
                        let (_, children) = members.explode();
                        for child in children {
                            insert_membership(&mut member_of_tree, child, 0, Placement::After);
                        }
                    }

                    let entry_name = entry_attributes
                        .sam_account_name
                        .unwrap_or(entry_attributes.object_name.to_string());
                    let mut members_panel = siv
                        .find_name::<Panel<NamedView<TreeView<MembershipTreeEntry>>>>(MEMBERS_PANEL)
                        .unwrap();
                    members_panel.set_title(format!("Members of '{entry_name}'"));

                    let mut member_of_panel = siv
                        .find_name::<Panel<NamedView<TreeView<MembershipTreeEntry>>>>(
                            MEMBEROF_PANEL,
                        )
                        .unwrap();
                    member_of_panel.set_title(format!("'{entry_name}' is member of"));
                }
                Err(_) => {
                    siv.quit();
                }
            },
            _ => {
                log::error!("unable to acquire receiver lock");
                siv.quit();
            }
        }
    }
}

fn enlarge_tree(siv: &mut Cursive) {
    let mut left_panel = siv
        .find_name::<ResizedView<Panel<ScrollView<NamedView<TreeView<TreeEntry>>>>>>(LEFT_PANEL)
        .unwrap();
    siv.with_user_data(move |tree_view_width| {
        *tree_view_width += 1;
        left_panel.set_width(cursive::view::SizeConstraint::Fixed(*tree_view_width));
    });
}

fn shrink_tree(siv: &mut Cursive) {
    let mut left_panel = siv
        .find_name::<ResizedView<Panel<ScrollView<NamedView<TreeView<TreeEntry>>>>>>(LEFT_PANEL)
        .unwrap();
    siv.with_user_data(move |tree_view_width| {
        *tree_view_width -= 1;
        left_panel.set_width(cursive::view::SizeConstraint::Fixed(*tree_view_width));
    });
}

fn set_active_tab(siv: &mut Cursive, tab_id: &str) {
    let mut tabs = siv.find_name::<TabPanel>(TABS).unwrap();
    tabs.set_active_tab(tab_id).unwrap();
}