//  ------------------------------------------------------------------
//  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/>.
//  ------------------------------------------------------------------

use crate::AironeError;
use crate::Operation;
use crate::SingleChange;

use std::io::{BufRead, BufWriter, Read, Write};

/// A value that can be converted to a String
/// properly escaping characters that are not
/// allowed in airone's CSV format
///
/// Sometimes it's enough to format!() the value,
/// sometimes it needs custom conversions.
pub trait PersistableValue
{
    fn to_persistable_string(&self) -> String;
}

/// A value that can be converted from the String
/// to its actual type.
///
/// Sometimes it's enough to parse the value,
/// sometimes it needs custom conversions.
pub trait LoadableValue
{
    fn from_persistable_string(s: &str) -> Self;
}

macro_rules! impl_persistable_value_with_format {
    ($($t:ty),*) => {
        $(
            impl PersistableValue for $t
            {

                fn to_persistable_string(&self) -> String
                {
                    format!("{}", &self)
                }
            }
        )*
    };
}
impl_persistable_value_with_format!(
    bool, i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64
);

macro_rules! impl_loadable_value_with_parse {
    ($($t:ty),*) => {
        $(
            impl LoadableValue for $t
            {
                fn from_persistable_string(s: &str) -> $t
                {
                    return (s.parse::<$t>().unwrap()).clone()
                }
            }
        )*
    };
}
impl_loadable_value_with_parse!(
    bool, i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64
);

impl PersistableValue for String
{
    fn to_persistable_string(&self) -> String
    {
        let a = &self.clone();
        return a
            .replace("\n", "\\n")
            .replace("\r", "\\r")
            .replace("\t", "\\t")
            .replace("\"", "\\\"");
    }
}
impl LoadableValue for String
{
    fn from_persistable_string(s: &str) -> String
    {
        let a = s.clone();
        return a
            .replace("\\n", "\n")
            .replace("\\r", "\r")
            .replace("\\t", "\t")
            .replace("\\\"", "\"");
    }
}

impl<T> PersistableValue for Option<T>
where
    T: PersistableValue
{
    fn to_persistable_string(&self) -> String
    {
        if let Some(el) = &self
        {
            return el.to_persistable_string();
        }
        else
        {
            return String::new();
        }
    }
}

impl<A: LoadableValue> LoadableValue for Option<A>
{
    fn from_persistable_string(s: &str) -> Option<A>
    {
        if s.len() > 0
        {
            let b: A = LoadableValue::from_persistable_string(s);
            return Some(b);
        }
        else
        {
            return None;
        }
    }
}

/// Represents a struct that can be
/// serialized as a single line.
///
/// Each field type of the struct must implement
/// [PersistableValue]
pub trait CsvSerializable
{
    fn serialize_object(&self) -> String;
}

/// Represents a struct that can be
/// deserialized from a single line.
///
/// Each field type of the struct must implement
/// [LoadableValue]
pub trait CsvLoadable
{
    fn load_object(s: &String) -> Self;
}

pub trait GetSetObject
{
    fn set_str(&mut self, key: &str, value: &str);
}

/// This trait exposes public methods to access the data
pub trait Database<T>: InternalDatabaseMethods<T>
where
    T: CsvLoadable + CsvSerializable + GetSetObject
{
    /// 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>
    {
        match self.get_elements().get(index)
        {
            Some(e) => Ok(e),
            None => Err(AironeError::OutOfBound)
        }
    }

    /// 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>
    {
        return self.get_elements();
    }

    /// Adds a new element to the list at the given index position
    fn insert(&mut self, index: usize, element: T) -> Result<(), AironeError>
    {
        self.transact_insert_change(self.internal_op_add(&element, index))?;
        self.get_elements_mut().insert(index, element);
        Ok(())
    }

    /// Adds a new element to the end of the list
    fn push(&mut self, element: T) -> Result<(), AironeError>
    {
        return self.insert(self.get_elements().len(), element);
    }

    /// 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>
    {
        let current_autocommit_state = self.get_auto_commit();

        self.set_auto_commit(false);
        for el in elements
        {
            self.push(el)?;
        }
        self.set_auto_commit(current_autocommit_state);
        if self.get_auto_commit()
        {
            self.commit()?;
        }
        return Ok(());
    }

    /// Removes the first element of the list
    fn pop(&mut self) -> Result<(), 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(AironeError::ListAlreadyEmpty);
        }
    }

    /// Removes the element at the specified index from the list
    fn remove(&mut self, index: usize) -> Result<(), AironeError>
    {
        if self.get_elements().len() == 0
        {
            self.rollback()?;
            return Err(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(AironeError::OutOfBound);
        }
    }

    /// 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>
    {
        for index in indices.iter()
        {
            if index >= &self.get_elements().len()
            {
                self.rollback()?;
                return Err(AironeError::OutOfBound);
            }
        }
        if indices.len() > self.get_elements().len()
        {
            self.rollback()?;
            return Err(AironeError::OutOfBound);
        }

        let current_autocommit_state = self.get_auto_commit();
        self.set_auto_commit(false);

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

        self.set_auto_commit(current_autocommit_state);
        if self.get_auto_commit()
        {
            self.commit()?;
        }
        Ok(())
    }

    /// Returns the current number of elements in the list
    fn len(&self) -> usize
    {
        self.get_elements().len()
    }

    /// 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
    {
        return self
            .get_elements()
            .iter()
            .enumerate()
            .filter(|(_k, v)| f(v))
            .map(|(k, _v)| k)
            .collect();
    }

    // Transazioni
    /// Commits a transaction by saving change to disk
    fn commit(&mut self) -> Result<(), AironeError>
    {
        let list_changes = self.transact_get_list().clone();
        let writer = self.get_buf_writer();
        for el in list_changes
        {
            if writeln!(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.transact_get_list_mut() = Vec::new();
        Ok(())
    }

    /// Rolls back data in memory to the last successfull commit.
    fn rollback(&mut self) -> Result<(), AironeError>
    {
        self.transact_get_list_mut().reverse();
        let list_changes = self.transact_get_list().clone();
        for el in list_changes
        {
            Self::apply_single_edit(self.get_elements_mut(), &el.revert_change)?;
        }

        *self.transact_get_list_mut() = Vec::new();
        Ok(())
    }

    /// Enables or disables autocommit
    ///
    /// 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);

    /// Returns the current auto-commit configuration
    fn get_auto_commit(&self) -> bool;
}

/// Internal methods shared by all db instances
pub trait InternalDatabaseMethods<T>
where
    T: CsvLoadable + CsvSerializable + GetSetObject
{
    //------------------------------------------
    // Internal operations
    //------------------------------------------
    fn internal_op_add(&self, new_object: &T, index_for_revert: usize) -> crate::SingleChange
    {
        return crate::SingleChange {
            apply_change: crate::Operation::Add {
                index: index_for_revert,
                serialized_object: T::serialize_object(new_object)
            },
            revert_change: crate::Operation::Delete {
                index: index_for_revert
            }
        };
    }
    fn internal_op_delete(&self, index: usize, removed_object: &T) -> crate::SingleChange
    {
        return crate::SingleChange {
            apply_change: crate::Operation::Delete { index: index },
            revert_change: crate::Operation::Add {
                index: index,
                serialized_object: removed_object.serialize_object()
            }
        };
    }
    fn internal_op_edit<C: PersistableValue>(
        &self,
        index: usize,
        key: &str,
        old_value: &C,
        new_value: &C
    ) -> crate::SingleChange
    {
        return crate::SingleChange {
            apply_change: crate::Operation::Edit {
                index,
                field_name: key.to_string(),
                new_value_str: new_value.to_persistable_string()
            },
            revert_change: crate::Operation::Edit {
                index,
                field_name: key.to_string(),
                new_value_str: old_value.to_persistable_string()
            }
        };
    }

    //
    fn get_elements(&self) -> &Vec<T>;
    fn get_elements_mut(&mut self) -> &mut Vec<T>;
    fn get_buf_writer(&mut self) -> &mut std::io::BufWriter<std::fs::File>;
    fn apply_single_edit(elements: &mut Vec<T>, operation: &Operation) -> Result<(), AironeError>
    {
        match operation
        {
            Operation::Add {
                index,
                serialized_object
            } =>
            {
                let el: T = T::load_object(&serialized_object);
                elements.insert(*index, el);
            }
            Operation::Delete { index } =>
            {
                elements.remove(*index);
            }
            Operation::Edit {
                index,
                field_name,
                new_value_str
            } =>
            {
                if let Some(el) = elements.get_mut(*index)
                {
                    el.set_str(field_name, new_value_str);
                }
                else
                {
                    return Err(crate::AironeError::OutOfBound);
                }
            }
        }

        Ok(())
    }
    fn transact_insert_change(&mut self, change: crate::SingleChange) -> Result<(), AironeError>;
    fn transact_get_list(&mut self) -> &Vec<SingleChange>;
    fn transact_get_list_mut(&mut self) -> &mut Vec<SingleChange>;

    /// Dumps the whole dataset to the given file writer
    fn full_dump<W>(objects: &Vec<T>, mut writer: BufWriter<W>)
    where
        W: Write
    {
        for element in objects
        {
            let string = element.serialize_object();
            writeln!(writer, "{}", string).unwrap();
        }
        writer.flush().unwrap();
    }

    /// Loads the whole dataset from a compacted file
    fn full_load(elements: &mut Vec<T>, filename: &str) -> Result<(), AironeError>
    {
        Self::load_base_data(elements, filename)?;
        Self::apply_edits(elements, filename)?;

        Ok(())
    }

    // ------------------------------------------
    // 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<T>, filename: &str) -> Result<(), AironeError>
    {
        // 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);
            for line in buf.lines()
            {
                elements.push(T::load_object(match &line
                {
                    Ok(e) => e,
                    Err(_) => return Err(AironeError::IOError)
                }));
            }
            Ok(())
        }
        else
        {
            match std::fs::File::create(format!("{}{}", filename, ".csv"))
            {
                Ok(_) => Ok(()),
                Err(_) => return Err(AironeError::IOError)
            }
        }
    }

    /// Apply modifications contained
    /// in the transaction log file
    fn apply_edits(elements: &mut Vec<T>, filename: &str) -> Result<(), AironeError>
    {
        {
            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<T>, filename: &str) -> Result<(), AironeError>
    {
        let file = std::fs::OpenOptions::new()
            .create(true)
            .write(true)
            .truncate(true)
            .open(format!("{}{}", filename, ".csv"))
            .unwrap();
        let mut writer = std::io::BufWriter::new(file);
        Self::full_dump(elements, writer);

        Ok(())
    }
}