use std::ffi::c_void;

use std::path::Path;

use std::path::PathBuf;

use libloading::Library;

use libloading::Symbol;

use log::info;

use tempfile::TempDir;

use tempfile::tempdir;

use toml::Table;

use merc_data::DataExpression;

use merc_sabre::RewriteEngine;

use merc_sabre::RewriteSpecification;

use merc_sabre_ffi::DataExpressionFFI;

use merc_sabre_ffi::DataExpressionRefFFI;

use merc_sabre_ffi::SabreRewriteVTable;

use merc_sabre_ffi::data_expression_ref_from_term;

use merc_sabre_ffi::into_data_expression;

use merc_sabre_ffi::rewrite_vtable;

use merc_utilities::MercError;

use crate::generate;

use crate::library::RuntimeLibrary;

pub struct SabreCompilingRewriter {

    /// Cached `rewrite` entry point of `library`. Resolved once in `new`; valid

    /// for as long as `library` stays loaded.

    rewrite_fn: extern "C-unwind" fn(&DataExpressionRefFFI<'_>) -> DataExpressionFFI,

    /// Keeps every term hose raw address is baked into the generated

    /// library protected.

    _spec: RewriteSpecification,

    /// The loaded library, keeps rewrite_fn alive.

    _library: Library,

    /// Keep the temporary directory alive so it is not removed while the

    /// library is still mapped. `None` when a caller-managed local directory is

    /// used instead.

    _temp_dir: Option<TempDir>,

}

impl RewriteEngine for SabreCompilingRewriter {

        // SAFETY: `result` is an owned handle produced by the generated

        // `rewrite` entry point (always via the host `create`/`protect`), so it

        // wraps a live `Box<DataExpression>`.

}

impl SabreCompilingRewriter {

    /// Creates a new compiling rewriter for the given specifications.

    ///

    /// - use_local_workspace: Use the development version of the toolset instead of referring to the github one.

    /// - use_local_tmp: Use a relative 'tmp' directory instead of using the system directory. Mostly used for debugging purposes.

    ///

    /// - [`RewriteEngine`]

        // Only allocate a system temporary directory when one is needed; the

        // local-tmp path uses a fixed `./tmp` directory instead.

        };

                "merc_sabre-ffi = {{ path = '{}' }}",

            ));

        } else {

            // Pin to the host's git commit so the loaded library's `#[repr(C)]`

            // vtable layout matches the host exactly.

            } else {

            }

        }

        // Write the output source file(s).

        // Install the host vtable into the loaded library exactly once and cache

        // the `rewrite` entry point. All term-pool access in the library is

        // routed back through the vtable, so the library never touches its own

        // (duplicated) term pool.

        //

        // SAFETY: `initialise` and `rewrite` have the signatures emitted by the

        // code generator. The vtable's function pointers live in the host binary

        // for the whole process, satisfying the contract of `set_rewrite_vtable`.

        };

}

#[cfg(test)]

mod tests {

    use test_log::test;

    use merc_data::to_untyped_data_expression;

    use merc_rec_tests::load_rec_from_strings;

    use merc_sabre::RewriteEngine;

    use super::SabreCompilingRewriter;

    #[test]

    #[cfg_attr(miri, ignore)] // Miri does not support FFI.

                120, // 5! = 120.

                "The rewritten result does not match the expected result"

            );

        }

}