use beancount_pretty_printer::Config as PrettyPrinterConfig;

pub use config::Config;

use color_eyre::eyre::format_err;
use color_eyre::Help;
use color_eyre::Report;
use color_eyre::Result;

#[derive(Debug)]
pub struct Config {
    pub base_directory: Utf8PathBuf,

mod config;

    pub pretty_printer: PrettyPrinterConfig,
}
#[derive(Debug, Snafu)]
pub struct TreeWriterError(Error);

enum Error {
    #[snafu(display("encountered unsupported directive while indexing: {directive:?}"))]
    IndexingDirective {
        backtrace: Backtrace,
        directive: Directive,
    },
    #[snafu(display("error while pretty printing directives for key {index:?} to {file}"))]
    PrettyPrinting {
        backtrace: Backtrace,
        file: Utf8PathBuf,
        index: DirectiveIndex,
        source: io::Error,
    },
}

pub struct Error(InnerError);

    config: Config,

    config: config::Config,

    pub fn new(config: Config) -> Self {

    pub fn new(config: config::Config) -> Self {

        let pretty_printer_config = match self.config.pretty_printer {
            config::PrettyPrinterConfig::GloballyDerived => Some(
                beancount_pretty_printer::Config::derive_from_directives(&directives),
            ),
            config::PrettyPrinterConfig::LocallyDerived => None,
            config::PrettyPrinterConfig::Static(config) => Some(config),
        };

            .map(|(index, directives)| self.write_month(index, directives))

            .map(|(index, directives)| self.write_month(pretty_printer_config, index, directives))

            Err(errors.into_iter().fold(
                format_err!("encountered errors while writing directives to file tree"),
                Report::error,
            ))

            todo!("convert errors to summarized report")

        pretty_printer_config: Option<beancount_pretty_printer::Config>,

    ) -> Result<(), Error> {

    ) -> Result<(), InnerError> {

        let file = index.file_in(&self.config.base_directory);

        let pretty_printer_config = pretty_printer_config.unwrap_or_else(|| {
            beancount_pretty_printer::Config::derive_from_directives(&directives)
        });
        let file = index.file_in(&self.config.output_path);

                PrettyPrinter::buffered(self.config.pretty_printer, file)
                    .print_directives(&directives)

                PrettyPrinter::buffered(pretty_printer_config, file).print_directives(&directives)

    type Error = Error;

    type Error = InnerError;

}
#[derive(Debug, Snafu)]
enum InnerError {
    #[snafu(display("encountered unsupported directive while indexing: {directive:?}"))]
    IndexingDirective {
        backtrace: Backtrace,
        directive: Directive,
    },
    #[snafu(display("error while pretty printing directives for key {index:?} to {file}"))]
    PrettyPrinting {
        backtrace: Backtrace,
        file: Utf8PathBuf,
        index: DirectiveIndex,
        source: io::Error,
    },

type Result<T, E = Error> = std::result::Result<T, E>;

[dependencies.beancount-pretty-printer]
path = "../beancount-pretty-printer"

# Workspace dependencies
beancount-pretty-printer.path = "../beancount-pretty-printer"
beancount-types.path = "../beancount-types"

[dependencies.beancount-types]
path = "../beancount-types"

# Inherited from workspace
serde.workspace = true

use serde::Deserialize;

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]

#[derive(Clone, Copy, Debug)]

#[derive(Clone, Copy, Debug, Deserialize)]

serde.workspace = true