//  ------------------------------------------------------------------
//  Airone
//  is a Rust library which provides a simple in-memory,
//  write-on-update database that is persisted
//  to an append-only transaction file.
//
//  Copyright © 2022 Massimo Gismondi
//
//  This file is part of Airone.
//  Airone is free software: you can redistribute it and/or
//  modify it under the terms of the GNU Affero General Public License
//  as published by the Free Software Foundation, either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU Affero General Public License
//  along with this program. If not, see <https://www.gnu.org/licenses/>.
//  ------------------------------------------------------------------

#![doc = include_str!("../DOCS.md")]

pub use paste;
pub use std;
mod error;
pub use error::AironeError;
mod traits;
pub use traits::{LoadableValue, PersistableValue};

mod query_build;
pub use query_build::Query;

#[cfg(test)]
mod tests;

/// A single change in the database,
/// that can be applied or reverted
#[derive(Clone)]
pub struct SingleChange
{
    pub apply_change: Operation,
    pub revert_change: Operation
}

/// Represents an internal operations as an enumerative type.
/// Each operation includes all needed fields.
/// 
#[derive(Clone, PartialEq)]
pub enum Operation
{
    /// Add operation. Includes the index where
    /// the new item will be inserted
    /// and a String representation of the new object to add
    Add
    {
        index: usize,
        serialized_object: String
    },
    /// A Delete operations. Only needs the index of the element to remove
    Delete
    {
        index: usize
    },
    /// An Edit operation.
    /// Expects the index of the element to change,
    /// plus the field name, field type and the new value to insert, converted to a String.
    /// 
    /// You can obtain the String representation of a value using the [PersistableValue::to_persistable_string()] method.
    Edit
    {
        variable_type: String,
        index: usize,
        field_name: String,
        new_value_str: String
    }
}
impl Operation
{
    /// Tries to create an [Operation] enum from a line string in Airone format.
    pub fn parse_line(line: &str) -> Result<Operation, AironeError>
    {
        let mut parts_iter = line.split("\t");
        let tipo_op = parts_iter.next().unwrap();
        if tipo_op == "A"
        {
            // Aggiungi un elemento
            let index: usize = parts_iter.next().unwrap().parse().unwrap();
            let obj_string = parts_iter.collect::<Vec<&str>>().join("\t");
            return Ok(Operation::Add {
                index,
                serialized_object: obj_string
            });
        }
        else if tipo_op == "D"
        {
            let index: usize = parts_iter.next().unwrap().parse().unwrap();
            return Ok(Operation::Delete { index });
        }
        else if tipo_op == "E"
        {
            // formato:
            // E indice campo valore
            let my_type: String = parts_iter.next().unwrap().to_string();
            let index: usize = parts_iter.next().unwrap().parse().unwrap();
            let field: String = parts_iter.next().unwrap().to_string();
            let value_str: String = parts_iter.next().unwrap().to_string();

            return Ok(Operation::Edit {
                variable_type: my_type,
                index,
                field_name: field,
                new_value_str: value_str
            });
        }
        else
        {
            return Err(AironeError::ParseFailed);
        }
    }

    /// Converts an [Operation] to a properly formatted String, so it can be persisted to disk. 
    pub fn to_line(&self) -> String
    {
        match &self
        {
            Operation::Add {
                index,
                serialized_object
            } =>
            {
                format!("A\t{}\t{}",
                    index,
                    serialized_object
                )
            }
            Operation::Delete { index } =>
            {
                format!("D\t{}", index)
            }
            Operation::Edit {
                variable_type,
                index,
                field_name,
                new_value_str
            } =>
            {
                format!("E\t{}\t{}\t{}\t{}",
                    variable_type,
                    index,
                    field_name,
                    new_value_str
                )
            }
        }
    }
}

// Spiegazione della lifetime del Deserialize
// https://users.rust-lang.org/t/serde-generics-implement-deserialize-with-lifetime/45683/2

/// This trait exposes public methods to access the data
pub trait Database<T>
{
    /// Constructor method, initializing the save file
    /// named as the struct you passed to the [airone_db!] macro
    fn new() -> Self;

    /// Constructor method, initializing the save file
    /// using the given name.
    ///
    /// Do _NOT_ include the file extension.
    fn new_with_filename(custom_filename: &str) -> Self;

    /// Returns a reference to the element at the provided index
    fn get(&self, index: usize) -> Result<&T, AironeError>;

    /// Returns a non-mutable reference to the inner list.
    ///
    /// You are forced to change data through the provided methods
    /// of Airone, so that changes are correctly persisted.
    fn get_all(&self) -> &Vec<T>;

    /// Adds a new element to the list at the given index position
    fn insert(&mut self, index: usize, element: T) -> Result<(), AironeError>;

    /// Adds a new element to the end of the list
    fn push(&mut self, element: T) -> Result<(), AironeError>;

    /// Adds multiple elements to the end of the list, automatically reducing the number of syscalls to write them to disk
    fn bulk_push(&mut self, elements: Vec<T>) -> Result<(), AironeError>;

    /// Removes the first element of the list
    fn pop(&mut self) -> Result<(), AironeError>;

    /// Removes the element at the specified index from the list
    fn remove(&mut self, index: usize) -> Result<(), AironeError>;

    /// Removes the elements at the specified indices from the list,
    /// automatically reducing the number of syscalls to write them to disk
    fn bulk_remove(&mut self, indices: Vec<usize>) -> Result<(), AironeError>;

    /// Returns the current number of elements in the list
    fn len(&self) -> usize;

    /// Filters the elements with the given predicate.
    /// Returns a list of indices that match the filter.
    ///
    /// You can later use those indices with [bulk_remove](Database::bulk_remove) methods or `bulk_set_$field_name` setters generated by the macro.
    fn filter<F>(&self, f: F) -> Vec<usize>
    where
        F: Fn(&T) -> bool;

    // Transazioni
    /// Commits a transaction by saving change to disk
    fn commit(&mut self) -> Result<(), AironeError>;

    /// Rolls back data in memory to the last successfull commit.
    fn rollback(&mut self) -> Result<(), AironeError>;
    /// Enables or disables autocommit
    fn set_auto_commit(&mut self, new_state: bool);
}

/// This macro creates a new struct which will be used to interact with the underlying data.
///
/// The resulting struct implements the [Database] trait and also generates appropriate getter and setter methods for each struct field.
#[macro_export]
macro_rules! airone_db
{
    (
        $(#[$meta:meta])*
        $vis:vis struct $struct_name:ident
        {
            $(
                $field_vis:vis $field_name:ident : $field_type:ty
            ),*
        }
    ) => {
        // La struct ricevuta in input
        $(#[$meta])*
        $vis struct $struct_name
        {
            $(
                $field_vis $field_name: $field_type,
            )*
        }
        $crate::paste::paste!{
            impl $struct_name
            {
                $(
                    fn [<get_ $field_name>](&self) -> &$field_type
                    {
                        &self.$field_name
                    }
                    fn [<set_ $field_name>](&mut self, value: $field_type)
                    {
                        self.$field_name = value;
                    }
                )*
            }
        }

        // La struct Database esterna
        $crate::paste::paste!{
            $vis struct [<$struct_name AironeListProxy>]
            {
                buf_writer: $crate::std::io::BufWriter<$crate::std::fs::File>,
                elements: Vec<$struct_name>,
                current_transaction_changes: Vec<$crate::SingleChange>,
                autocommit: bool
            }

            impl [<$struct_name AironeListProxy>]
            {
                fn serialize_object(obj: &$struct_name) -> String
                {
                    let mut output = String::new();
                    $(
                        let value: Box<dyn $crate::PersistableValue> = Box::new(obj.$field_name.clone());
                        output.push_str(&format!(
                            "{}\t",
                            value.to_persistable_string()
                        ));
                    )*
                    output.pop();
                    return output;
                }
                fn deserialize_object(line: &str) -> $struct_name
                {
                    let mut parts = line.split("\t");
                    $(
                        let next_part = parts.next().unwrap().to_string();
                        let [<found_ $field_name>]: $field_type = $crate::LoadableValue::from_persistable_string(&next_part);
                    )*

                    let obj = $struct_name {
                        $(
                            $field_name: [<found_ $field_name>],
                        )*
                    };
                    return obj;
                }

                fn get_elements(&self) -> &Vec<$struct_name>
                {
                    return &self.elements;
                }
                fn get_elements_mut(&mut self) -> &mut Vec<$struct_name>
                {
                    return &mut self.elements;
                }
                fn get_buf_writer(&mut self) -> &mut $crate::std::io::BufWriter<$crate::std::fs::File>
                {
                    return &mut self.buf_writer;
                }
                fn apply_single_edit(elements: &mut Vec<$struct_name>, operation: &$crate::Operation)
                -> Result<(), $crate::AironeError>
                {
                    match operation
                    {
                        $crate::Operation::Add {
                            index,
                            serialized_object
                        } =>
                        {
                            let el: $struct_name = Self::deserialize_object(&serialized_object);
                            elements.insert(*index, el);
                        }
                        $crate::Operation::Delete { index } =>
                        {
                            elements.remove(*index);
                        }
                        $crate::Operation::Edit {
                            variable_type,
                            index,
                            field_name,
                            new_value_str
                        } =>
                        {
                            println!("matching {} {}", variable_type, field_name);
                            match (field_name.as_str(), variable_type.as_str()) {
                                $(
                                    (stringify!($field_name), stringify!($field_type)) =>
                                    {
                                        println!("matched {} {}", variable_type, field_name);
                                        let lo: $field_type = $crate::LoadableValue::from_persistable_string(new_value_str);
                                        if let Some(e) = elements.get_mut(*index)
                                        {
                                            e.[<set_ $field_name>](lo);
                                        }
                                        else
                                        {
                                            return Err($crate::AironeError::OutOfBound);
                                        }
                                    }
                                )*
                                _ => {return Err($crate::AironeError::ParseFailed);}
                            };
                        }
                    }

                    Ok(())
                }

                fn transact_insert_change(&mut self, change: $crate::SingleChange) -> Result<(), $crate::AironeError>
                {
                    self.current_transaction_changes.push(change);
                    if self.autocommit
                    {
                        self.commit()?;
                    }
                    Ok(())
                }
            }

            impl $crate::Database<$struct_name> for [<$struct_name AironeListProxy>]
            {
                /// Enables or disables autocommits.
                ///
                /// Autocommit means that each change is instantly flushed to disk without having to call `commit()`. The rollback() function is useless in this state.
                ///
                /// Disabled autocommit means the you have to manually commit or rollback changes.
                fn set_auto_commit(&mut self, new_state: bool)
                {
                    self.autocommit = new_state;
                }
                fn commit(&mut self)
                -> Result<(), $crate::AironeError>
                {
                    use $crate::std::io::Write;
                    for el in self.current_transaction_changes.clone()
                    {
                        if writeln!(self.get_buf_writer(), "{}", el.apply_change.to_line()).is_err()
                        {
                            return Err($crate::AironeError::IOError);
                        }
                    }

                    if self.get_buf_writer().flush().is_err()
                    {
                        return Err($crate::AironeError::IOError);
                    }

                    self.current_transaction_changes = Vec::new();
                    Ok(())
                }
                fn rollback(&mut self)
                -> Result<(), $crate::AironeError>
                {
                    self.current_transaction_changes.reverse();
                    for el in self.current_transaction_changes.clone()
                    {
                        Self::apply_single_edit(self.get_elements_mut(), &el.revert_change)?;
                    }
                    self.current_transaction_changes = Vec::new();
                    Ok(())
                }

                fn filter<F>(&self, f: F) -> Vec<usize>
                where F: Fn(&$struct_name) -> bool
                {
                    return self.get_elements().iter().enumerate()
                    .filter( |(_k, v)| { f(v) })
                    .map(|(k, _v)| { k }).collect();
                }

                fn new() -> Self
                {
                    const FILENAME: &str = stringify!($struct_name);
                    return Self::new_with_filename(FILENAME);
                }

                fn new_with_filename(custom_filename: &str) -> Self
                {
                    if cfg!(target_os="windows")
                    {
                        eprintln!("You're running a Windows operating system, but Airone is not supported on, has never been tested on and does not endorse proprietary operating systems.\n\
                        I encourage you to switch to an actually privacy-and-freedom respecting operating system such as Gnu/Linux.\n\
                        Head to https://www.fsf.org/windows for more information.");
                    }
                    else if cfg!(target_os="macos") || cfg!(target_os="ios")
                    {
                        eprintln!("You're running an Apple operating system, but Airone is not supported on, has never been tested on and does not endorse proprietary operating systems.\n\
                        I encourage you to switch to an actually privacy-and-freedom respecting operating system such as Gnu/Linux.\n\
                        Learn more at https://www.fsf.org/campaigns/apple");
                    }
                    {
                        // WSL
                        let output = std::process::Command::new("uname")
                        .arg("-a")
                        .output()
                        .expect("Failed to execute command");
                        let st =  String::from_utf8(output.stdout).unwrap();
                        if st.to_ascii_lowercase().contains("microsoft")
                        {
                            eprintln!("You're running airone inside of WSL, which is a compatibility layer and may unexpectedly break or introduce bugs. Airone has never been tested on WSL. Moreover, WSL limits your freedom as it makes you stick to a proprietary OS, but that's a personal decision. \n\
                            Anyway, to get the best from this library I highly encourage you to switch to a traditionally installed operating system such as Gnu/Linux instead.
                            ");
                        }
                    }


                    let mut starting_elements: Vec<$struct_name> = Vec::new();

                    Self::load_base_data(&mut starting_elements, custom_filename);
                    Self::apply_edits(&mut starting_elements, custom_filename).unwrap();
                    Self::compact(&mut starting_elements, custom_filename).unwrap();
                    let mut file = $crate::std::fs::OpenOptions::new()
                        .write(true)
                        .append(true)
                        .create(true)
                        .open(format!("{}{}", custom_filename, ".changes.csv"))
                        .unwrap();
                    return Self {
                        autocommit: true,
                        current_transaction_changes: Vec::new(),
                        elements: starting_elements,
                        buf_writer: $crate::std::io::BufWriter::new(
                            file
                        )
                    };
                }

                /// Read only access to the element at the specified index
                fn get(&self, index: usize) -> Result<&$struct_name, AironeError>
                {
                    match self.get_elements().get(index)
                    {
                        Some(e) => Ok(e),
                        None => Err(AironeError::OutOfBound)
                    }
                }
                fn get_all(&self) -> &Vec<$struct_name>
                {
                    return self.get_elements();
                }

                fn insert(&mut self, index: usize, element: $struct_name) -> Result<(), AironeError>
                {
                    self.transact_insert_change(
                        self.internal_op_add(&element, index)
                    )?;
                    self.get_elements_mut().insert(index, element);
                    // println!("{:?}", self.get_elements());
                    Ok(())
                }

                fn push(&mut self, element: $struct_name) -> Result<(), $crate::AironeError>
                {
                    return self.insert(self.get_elements().len(), element);
                }
                fn bulk_push(&mut self, elements: Vec<$struct_name>) -> Result<(), $crate::AironeError>
                {
                    let current_autocommit_state = self.autocommit;

                    self.autocommit = false;
                    for el in elements
                    {
                        self.push(el)?;
                    }
                    self.autocommit = current_autocommit_state;
                    if self.autocommit
                    {
                        self.commit()?;
                    }
                    return Ok(())
                }
                fn pop(&mut self) -> Result<(), $crate::AironeError>
                {
                    if let Some(el) = self.get_elements_mut().pop()
                    {
                        self.transact_insert_change(
                            self.internal_op_delete(self.get_elements().len(), &el)
                        )?;
                        Ok(())
                    }
                    else
                    {
                        return Err($crate::AironeError::ListAlreadyEmpty)
                    }
                }
                fn remove(&mut self, index: usize) -> Result<(), $crate::AironeError>
                {
                    if self.get_elements().len() == 0
                    {
                        self.rollback()?;
                        return Err($crate::AironeError::ListAlreadyEmpty);
                    }
                    if index < self.get_elements().len()
                    {
                        let el = self.get_elements_mut().remove(index);
                        self.transact_insert_change(
                            self.internal_op_delete(index, &el)
                        )?;
                        return Ok(())
                    }
                    else
                    {
                        self.rollback()?;
                        return Err($crate::AironeError::OutOfBound);
                    }
                }
                fn bulk_remove(&mut self, indices: Vec<usize>) -> Result<(), $crate::AironeError>
                {
                    for index in indices.iter()
                    {
                        if index >= &self.get_elements().len()
                        {
                            self.rollback()?;
                            return Err($crate::AironeError::OutOfBound);
                        }
                    }
                    if indices.len() > self.get_elements().len()
                    {
                        self.rollback()?;
                        return Err($crate::AironeError::OutOfBound);
                    }


                    let current_autocommit_state = self.autocommit;
                    self.autocommit = false;


                    let mut my_indices = indices.clone();
                    my_indices.sort();
                    my_indices.reverse();
                    for index in my_indices.iter()
                    {
                        self.remove(index.clone())?;
                    }

                    self.autocommit = current_autocommit_state;
                    if self.autocommit
                    {
                        self.commit()?;
                    }
                    Ok(())
                }


                fn len(&self) -> usize
                {
                    self.get_elements().len()
                }
            }

            impl [<$struct_name AironeListProxy>]
            {
                // Getter e setter,
                // che chiamano internamente il salvataggio
                // su file
                $(
                    $field_vis fn [<get_ $field_name>](&self, index: usize) -> Result<&$field_type,AironeError>
                    {
                        if let Some(e) = &self.elements.get(index)
                        {
                            return Ok(&e.$field_name)
                        }
                        else
                        {
                            return Err(AironeError::OutOfBound)
                        }
                    }
                    $field_vis fn [<set_ $field_name>](&mut self, index: usize, value: $field_type) -> Result<(),AironeError>
                    {
                        if let Some(el) = self.get_elements_mut().get_mut(index)
                        {
                            let old_value = el.$field_name.clone();
                            el.$field_name = value.clone();

                            self.transact_insert_change(
                                self.internal_op_edit(
                                    stringify!($field_type),
                                    index,
                                    stringify!($field_name),
                                    &old_value,
                                    &value
                                )
                            )?;
                            return Ok(())
                        }
                        else
                        {
                            return Err(AironeError::OutOfBound);
                        }
                    }

                    $field_vis fn [<set_bulk_ $field_name>](&mut self, indices: Vec<usize>, value: $field_type) -> Result<(),AironeError>
                    {
                        for index in indices
                        {
                            let el: &mut $struct_name = match self.get_elements_mut().get_mut(index)
                            {
                                Some(e) => e,
                                None => return Err(AironeError::OutOfBound)
                            };
                            let old_value = el.$field_name.clone();
                            el.$field_name = value.clone();

                            self.transact_insert_change(
                                self.internal_op_edit(
                                    stringify!($field_type),
                                    index,
                                    stringify!($field_name),
                                    &old_value,
                                    &value
                                )
                            )?;
                        }
                        return Ok(())
                    }
                )*


                fn full_dump(objects: &Vec<$struct_name>) -> Vec<String>
                {
                    let mut output:Vec<String> = Vec::new();
                    for object in objects
                    {
                        output.push(
                            Self::serialize_object(object)
                        );
                    }
                    return output;
                }
                fn full_load(reader: std::io::BufReader<std::fs::File>) -> Vec<$struct_name>
                {
                    use $crate::std::io::BufRead;
                    let mut found_elements: Vec<$struct_name> = Vec::new();
                    for line in reader.lines()
                    {
                        found_elements.push(
                            Self::deserialize_object(&line.unwrap())
                        );
                    }
                    return found_elements;
                }

                //------------------------------------------
                // Operazioni interne per il salvataggio,
                // tutte salvano su file la modifica
                //------------------------------------------
                //
                fn internal_op_add(&self, new_object: &$struct_name, index_for_revert: usize) -> $crate::SingleChange
                {
                    return $crate::SingleChange{
                        apply_change: $crate::Operation::Add{
                            index: index_for_revert,
                            serialized_object: Self::serialize_object(new_object)
                        },
                        revert_change: $crate::Operation::Delete{
                            index: index_for_revert
                        }
                    };
                }
                fn internal_op_delete(&self, index: usize, removed_object: &$struct_name) -> $crate::SingleChange
                {
                    return $crate::SingleChange{
                        apply_change: $crate::Operation::Delete{
                            index: index
                        },
                        revert_change: $crate::Operation::Add{
                            index: index,
                            serialized_object: Self::serialize_object(removed_object)
                        }
                    };
                }
                fn internal_op_edit<C: $crate::PersistableValue>(
                    &self, el_type: &str, index: usize, key: &str, old_value: &C, new_value: &C)
                    -> $crate::SingleChange
                {
                    return $crate::SingleChange{
                        apply_change: $crate::Operation::Edit{
                            variable_type: el_type.to_string(),
                            index,
                            field_name: key.to_string(),
                            new_value_str: new_value.to_persistable_string()
                        },
                        revert_change: $crate::Operation::Edit{
                            variable_type: el_type.to_string(),
                            index,
                            field_name: key.to_string(),
                            new_value_str: old_value.to_persistable_string()
                        }
                    };
                }

                // ------------------------------------------
                // Quando il database viene istanziato,
                // devo caricare il JSON base e poi
                // applicare le modifiche
                // ------------------------------------------
                /// Carica il JSON di base senza applicare le modifiche
                fn load_base_data(elements: &mut Vec<$struct_name>, filename: &str)
                {
                    use std::io::BufRead;
                    // Carico JSON di base
                    if let Ok(file) = std::fs::OpenOptions::new()
                        .read(true)
                        .open(format!("{}{}", filename, ".csv"))
                    {
                        let buf = std::io::BufReader::new(file);
                        let mut els: Vec<$struct_name> = Vec::new();
                        for (i, line) in buf.lines().enumerate()
                        {
                            els.push(
                                Self::deserialize_object(&line.unwrap())
                            );
                        }

                        for el in els
                        {
                            elements.push(el);
                        }
                    }
                    else
                    {
                        std::fs::File::create(format!("{}{}", filename, ".csv")).unwrap();
                    }
                }

                /// Applica le modifiche sui dati
                /// già caricati in memoria
                fn apply_edits(elements: &mut Vec<$struct_name>, filename: &str)
                -> Result<(), $crate::AironeError>
                {
                    use std::io::BufRead;
                    {
                        let file = match std::fs::OpenOptions::new()
                            .read(true)
                            .open(format!("{}{}", filename, ".changes.csv"))
                            {
                                Ok(e) => {e},
                                Err(_) => {
                                    return Ok(());
                                }
                            };
                        let reader = std::io::BufReader::new(file);

                        for line in reader.lines()
                        {
                            let my_line = line.unwrap();
                            Self::apply_single_edit(elements, &$crate::Operation::parse_line(&my_line)?)?;
                        }
                    }

                    // Svuoto file modifiche
                    std::fs::File::create(format!("{}{}", filename, ".changes.csv")).unwrap();

                    Ok(())
                }

                /// Salva su file il JSON intero compattato
                /// ed elimina il file delle modifiche
                fn compact(elements: &Vec<$struct_name>, filename: &str)
                -> Result<(), $crate::AironeError>
                {
                    use std::io::Write;
                    let mut file = std::fs::OpenOptions::new()
                        .create(true)
                        .write(true)
                        .truncate(true)
                        .open(format!("{}{}", filename, ".csv"))
                        .unwrap();
                    let mut writer = std::io::BufWriter::new(file);
                    for element in elements
                    {
                        let string = Self::serialize_object(element);
                        writeln!(writer, "{}", string).unwrap();
                    }

                    Ok(())
                }
            }
        }
    }
}