import { Button, VerticalBox, HorizontalBox, ScrollView } from "std-widgets.slint";

import { Button, VerticalBox, HorizontalBox, ScrollView, ListView } from "std-widgets.slint";

component ChannelsList {
    in-out property <[string]> channels;
    in-out property <int> active;

    VerticalBox {
        alignment: start;
        spacing: 0;
        preferred-width: 150px;
        Text {
            text: "channels";
        }
        // TODO convert to a (Standard)ListView?
        for ch[index] in channels: HorizontalBox {
            alignment: start;
            spacing: 0;
            padding: 0;
            Rectangle {
                width: 10px;
                height: 10px;
                visible: index == root.active;
                background: blue;
            }
            Text {
                text: "\{ch}";
            }
        }
    }
}

    in-out property <string> channel_list: "";

    in-out property <[string]> channels <=> chs.channels;
    in-out property <int> active-channel <=> chs.active;

    width: 600px;
    height: 400px;

            VerticalBox {
                alignment: start;
                preferred-width: 150px;
                Text {
                    text: "channels";
                }
                Text {
                    text: "\{root.channel_list}";
                }

            chs := ChannelsList {
                channels: [];
                active: 0;

            // TODO convert to a (Standard)ListView?

                preferred-width: 500px;

                    preferred-width: 500px;

use slint::{ModelRc, SharedString};

use slint::SharedString;

            ui.set_channel_list(SharedString::from(&channel_list));

            let channel_strs = channel_list
                .entries
                .into_iter()
                .map(SharedString::from)
                .collect::<Vec<_>>();
            ui.set_channels((&channel_strs[..]).into());
            ui.set_active_channel(i32::try_from(channel_list.active).unwrap_or(-1));

pub fn channel(exe: &std::path::Path, repo: &std::path::Path) -> Result<String, Error> {

pub fn channel(exe: &std::path::Path, repo: &std::path::Path) -> Result<ChannelsList, Error> {

    Ok(String::from_utf8(output.stdout)?)

    parse_channel_output(output.stdout)
}
fn parse_channel_output(output: Vec<u8>) -> Result<ChannelsList, Error> {
    let channels_str = String::from_utf8(output)?;
    let channels_list = channels_str.split('\n').map(|substr| substr.trim()).fold(
        ChannelsList::new(),
        |mut channels_list, ch_str| {
            if ch_str.starts_with("* ") {
                channels_list.active = channels_list.entries.len();
                channels_list.entries.push(ch_str[2..].to_string());
            } else {
                channels_list.entries.push(ch_str.to_string());
            }
            channels_list
        },
    );
    Ok(channels_list)

}
#[derive(Debug)]
pub struct ChannelsList {
    pub(crate) entries: Vec<String>,
    pub(crate) active: usize,

impl ChannelsList {
    pub(crate) fn new() -> Self {
        Self {
            entries: Vec::new(),
            active: usize::MAX,
        }
    }
}