//  ------------------------------------------------------------------
//  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;
pub mod prelude;
pub use prelude::*;
mod error;
mod query_build;
mod traits;
pub use query_build::Query;

#[cfg(test)]
mod tests;

/// An internal struct that represents
/// a change in data
/// 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, 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
    {
        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 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 {
                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 {
                index,
                field_name,
                new_value_str
            } =>
            {
                format!("E\t{}\t{}\t{}", index, field_name, new_value_str)
            }
        }
    }
}

#[macro_export]
macro_rules! airone_init {
    () => {
        pub struct AironeDb<T>
        where
            T: $crate::CsvLoadable + $crate::CsvSerializable
        {
            buf_writer: std::io::BufWriter<std::fs::File>,
            elements: Vec<T>,
            current_transaction_changes: Vec<$crate::SingleChange>,
            autocommit: 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
            ),*
        }
    ) => {
        // The struct received as an input
        $(#[$meta])*
        $vis struct $struct_name
        {
            $(
                $field_vis $field_name: $field_type,
            )*
        }
        $crate::paste::paste!{
            // Generating internal getter and setter methods.
            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;
                    }
                )*
            }

            impl $crate::CsvLoadable for $struct_name
            {
                fn load_object(s: &String) -> Self
                {
                    // Splits each field and makes a variable named "found_"+"fieldname".
                    let mut parts = s.split("\t");
                    $(
                        let next_part = parts.next().unwrap().to_string();
                        let [<found_ $field_name>]: $field_type = $crate::LoadableValue::from_persistable_string(&next_part);
                    )*

                    // Uses the temporary variables to instance a new object
                    let obj = Self {
                        $(
                            $field_name: [<found_ $field_name>],
                        )*
                    };
                    return obj;
                }
            }
            impl $crate::CsvSerializable for $struct_name
            {
                fn serialize_object(&self) -> String
                {
                    use $crate::PersistableValue;
                    let mut output = String::new();
                    $(
                        let value: $field_type = self.$field_name.clone();
                        output.push_str(&format!(
                            "{}\t",
                            value.to_persistable_string()
                        ));
                    )*
                    // Removes the useless \t at the end
                    output.pop();
                    return output;
                }
            }

            impl $crate::GetSetObject for $struct_name
            {
                fn set_str(&mut self, key: &str, value: &str)
                {
                    match key
                    {
                        $(
                            stringify!($field_name) => {
                                self.$field_name = $crate::LoadableValue::from_persistable_string(value)
                            },
                        )*
                        _ => {panic!("Key not found")}
                    }

                }
            }
        }

        // La struct Database esterna
        $crate::paste::paste!{
            impl $crate::Database<$struct_name> for AironeDb<$struct_name>
            {
                fn set_auto_commit(&mut self, new_state: bool)
                {
                    self.autocommit = new_state;
                }

                fn get_auto_commit(&self) -> bool
                {
                    return self.autocommit;
                }

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

                fn new_with_filename(custom_filename: &str) -> Self
                {
                    use $crate::prelude::InternalDatabaseMethods;
                    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 tested and 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 tested and 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. \n\
                            Anyway, to get the best from this library I highly encourage you to switch to a traditionally installed operating system such as a full Gnu/Linux installation instead.
                            ");
                        }
                    }


                    let mut starting_elements: Vec<$struct_name> = Vec::with_capacity(
                        Self::estimate_size(custom_filename)
                    );

                    Self::full_load(&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
                        )
                    };
                }
            }

            impl $crate::InternalDatabaseMethods<$struct_name> for AironeDb<$struct_name>
            {
                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 transact_insert_change(&mut self, change: $crate::SingleChange) -> Result<(), $crate::AironeError>
                {
                    self.current_transaction_changes.push(change);
                    if self.get_auto_commit()
                    {
                        self.commit()?;
                    }
                    Ok(())
                }
                fn transact_get_list(&mut self) -> &Vec<$crate::SingleChange>
                {
                    &self.current_transaction_changes
                }
                fn transact_get_list_mut(&mut self) -> &mut Vec<$crate::SingleChange>
                {
                    &mut self.current_transaction_changes
                }
            }

            impl AironeDb<$struct_name>
            {
                // 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>
                    {
                        use $crate::prelude::InternalDatabaseMethods;
                        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(
                                    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>
                    {
                        use $crate::prelude::InternalDatabaseMethods;
                        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(
                                    index,
                                    stringify!($field_name),
                                    &old_value,
                                    &value
                                )
                            )?;
                        }
                        return Ok(())
                    }
                )*
            }
        }
    }
}