// yt - A fully featured command line YouTube client
//
// Copyright (C) 2025 Benedikt Peetz <benedikt.peetz@b-peetz.de>
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This file is part of Yt.
//
// You should have received a copy of the License along with this program.
// If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.

pub mod dearrow;

#[macro_export]
macro_rules! pydict_get {
    (@$vm:expr, $value:expr, $name:literal, $into:ident) => {{
        match $value.get_item($name, $vm) {
            Ok(val) => $crate::pydict_cast!(val, $into),
            Err(_) => panic!(
                concat!(
                    "Expected '",
                    $name,
                    "' to be a key for the'",
                    stringify!($value),
                    "' py dictionary: {:#?}"
                ),
                $value
            ),
        }
    }};
}

#[macro_export]
macro_rules! pydict_cast {
    ($value:expr, $into:ident) => {{
        match $value.downcast::<$into>() {
            Ok(result) => result,
            Err(val) => panic!(
                concat!(
                    "Expected to be able to downcast value ({:#?}) as ",
                    stringify!($into)
                ),
                val
            ),
        }
    }};
    (@ref $value:expr, $into:ident) => {{
        match $value.downcast_ref::<$into>() {
            Some(result) => result,
            None => panic!(
                concat!(
                    "Expected to be able to downcast value ({:#?}) as ",
                    stringify!($into)
                ),
                $value
            ),
        }
    }};
}

#[macro_export]
macro_rules! wrap_post_processor {
    ($name:literal, $unwrap:ident, $wrapped:ident) => {
        use $crate::progress_hook::__priv::vm;

        /// # Errors
        /// - If the underlying function returns an error.
        /// - If python operations fail.
        pub fn $wrapped(vm: &vm::VirtualMachine) -> vm::PyResult<vm::PyObjectRef> {
            fn actual_processor(
                mut input: vm::function::FuncArgs,
                vm: &vm::VirtualMachine,
            ) -> vm::PyResult<vm::PyRef<vm::builtins::PyDict>> {
                let input = input
                    .args
                    .remove(0)
                    .downcast::<vm::builtins::PyDict>()
                    .expect("Should be a py dict");

                let output = match unwrapped_process(input, vm) {
                    Ok(ok) => ok,
                    Err(err) => {
                        return Err(vm.new_runtime_error(err.to_string()));
                    }
                };

                Ok(output)
            }

            let scope = vm.new_scope_with_builtins();

            scope.globals.set_item(
                "actual_processor",
                vm.new_function("actual_processor", actual_processor).into(),
                vm,
            )?;

            let local_scope = scope.clone();
            vm.run_code_string(
                local_scope,
                format!(
                    "
import yt_dlp

class {}(yt_dlp.postprocessor.PostProcessor):
    def run(self, info):
        info = actual_processor(info)
        return [], info

inst = {}()
",
                    $name, $name
                )
                .as_str(),
                "<embedded post processor initializing code>".to_owned(),
            )?;

            Ok(scope
                .globals
                .get_item("inst", vm)
                .expect("We just declared it"))
        }
    };
}