#![recursion_limit = "512"]
//! Database API using the table style system provided by this crate
mod models;
mod schema;
mod jrtables;
mod jrcolumns;
mod jrentries;
mod jrcells;
mod users;

use dotenvy::dotenv;
use std::env;
use diesel::mysql::MysqlConnection;
use diesel::prelude::*;
use std::hash::{Hash, DefaultHasher};
use std::collections::HashSet;
use diesel::deserialize::FromSql;
use diesel::deserialize;
use diesel::backend::Backend;
use diesel::sql_types::Integer;
use diesel::expression::Expression;


#[derive(PartialEq, Clone, Copy, diesel::FromSqlRow)]
#[repr(i32)]
pub enum FIELDTYPE {
    TEXT = 0,
    NUMBER = 1,
}

impl Expression for FIELDTYPE {
    type SqlType = Integer;
}

impl<DB> FromSql<Integer, DB> for FIELDTYPE
where DB: Backend, i32: FromSql<Integer,DB> {
    fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
	match i32::from_sql(bytes)? {
	    0 => Ok(FIELDTYPE::TEXT),
	    1 => Ok(FIELDTYPE::NUMBER),
	    x => Err(format!("Unknown field type {}.", x).into()),
	}
    }
}

impl From<isize> for FIELDTYPE {
    fn from(value: isize) -> Self {
	match value {
	    1 => FIELDTYPE::NUMBER,
	    x => FIELDTYPE::TEXT,
	}
    }
}
    
/// represents and summarised all relevant data of a table. 
/// Standard return type if whole tables should be returned
pub struct Tbl {
    /// table id of the represented object
    pub tblid: i32,
    pub name: String,
    pub column_names: Vec<String>,
    pub column_types: Vec<FIELDTYPE>,
    pub rows: Vec<TRow>,
}

/// Represents a table's row. 
/// Internal data structure is abstracted until strings.
#[derive(Hash, Clone, Debug)]
pub struct TRow {
    pub row_pos: i32,
    pub cells: Vec<String>,
}

impl PartialEq for TRow {
    fn eq(&self, other: &Self) -> bool {
	let mut hasher = DefaultHasher::new();
	self.hash(&mut hasher) == other.hash(&mut hasher)
    }
}
impl Eq for TRow {}

/// Identifies a user
/// All fields are unique within the db at any given point.
pub struct User {
    /// User's unique id.
    pub uid: i32,
    pub uname: String,
    pub email: String,
}

/// Connect to database.
/// Return value must be passed to most of the crate's functions.
pub fn establish_connection() -> MysqlConnection {
    dotenv().ok();
    let db_url = env::var("DATABASE_URL").expect("No database url set.");
    MysqlConnection::establish(&db_url)
	.unwrap_or_else(|_| panic!("Couldn't open database."))
}

/// Fetch one whole table from the database. Identified by it's ID.
/// Needs the id of the requesting user.
/// Returns:
///     A Tbl struct 
/// Or:
///     None 
///         if the table was not found or
///         if it could not be read or
///         if the requesting user is not the table's owner or
///         if there has been another error
///
pub fn get_table(conn: &mut MysqlConnection, tblid: i32, uid: i32) -> Option<Tbl> {
    let tbl = jrtables::get_tbl(conn, tblid);
    if tbl.is_err() {
	return None;
    }
    let tbl = tbl.unwrap();
    if tbl.owner_id != uid {
	return None;
    }
    let clmns = jrcolumns::get_clmns_of(conn, tblid);
    if clmns.is_err() {
	return None;
    }
    let clmns = clmns.unwrap();
    let mut clmn_nms = Vec::new();
    for clmn in &clmns {
	clmn_nms.push(clmn.name.clone());
    }
    let clmn_nms = clmn_nms;
    let mut clmn_ids = Vec::new();
    for clmn in &clmns {
	clmn_ids.push(clmn.id);
    }
    let clmn_ids = clmn_ids;
    let mut clmn_tps = Vec::new();
    for clmn in &clmns {
	clmn_tps.push(clmn.column_type);
    }
    let clmn_tps = clmn_tps;
    let rowids = jrentries::get_entries_of(conn, tblid);
    if rowids.is_err() {
	return None;
    }
    let rowids = rowids.unwrap();
    let mut rows = Vec::new();
    for rowid in rowids {
	let row = jrcells::get_entry_cells(conn, rowid.id);
	if row.is_err() {
	    return None;
	}
	let row = row.unwrap();
	let mut data = Vec::new();
	for cell in row {
	    data.push(cell.cell_value);
	}
	let data = data;
	rows.push(TRow { row_pos: rowid.row_pos, cells: data });
    }
    Some(Tbl { tblid: tbl.id, name: tbl.name, column_names: clmn_nms, column_types: clmn_tps,rows: rows })
}

pub fn sort_table(tbl: Tbl, sort_field: usize, sort_dir: u8) -> Tbl {
    let mut rows = tbl.rows;
    if sort_field == 0 {
	rows.sort_unstable_by_key(|a: &TRow| a.row_pos);
	if sort_dir == 1 {
	    rows.reverse();
	}
    }else {
	if tbl.column_types[sort_field-1] == FIELDTYPE::NUMBER {
	    rows.sort_by_key(|a: &TRow| a.cells[sort_field - 1].trim().parse::<i32>().expect("Number not a number."));
	}else {
	    rows.sort_by_key(|a: &TRow| a.cells[sort_field - 1].clone());
	}
	if sort_dir == 1 {
	    rows.reverse();
	}
    }
    let rows = rows;
    Tbl { tblid: tbl.tblid, name: tbl.name, column_names: tbl.column_names, column_types: tbl.column_types, rows: rows.clone() }
}

pub fn search_table(tbl: Tbl, search_fields: Vec<i32>, search_value: String) -> Tbl {
    let mut rows = tbl.rows;
    let mut field_sets = HashSet::new();
    for field in search_fields {
	for row in &rows {
	    if row.cells[field as usize].to_lowercase().contains(&search_value) {
		field_sets.insert(row.clone());
	    }
	}
    }
    Tbl { tblid: tbl.tblid, name: tbl.name, column_names: tbl.column_names, column_types: tbl.column_types, rows: Vec::from_iter(field_sets) }
}


pub fn get_tblnames(conn: &mut MysqlConnection, tblids: Vec<i32>) -> Option<Vec<String>> {
    let mut tblnames = Vec::new();
    for tblid in tblids {
	let tblname = jrtables::get_tbl(conn, tblid);
	if tblname.is_err() {
	    return None;
	}
	tblnames.push(tblname.unwrap().name);
    }
    Some(tblnames)
}

/// Returns a Vec of the ids of a user's table if the user exists, else None.
/// User is identified by its user ID.
pub fn get_user_tblids(conn: &mut MysqlConnection, uid: i32) -> Option<Vec<i32>> {
    let tblids = jrtables::get_tblids_uid(conn, uid);
    if tblids.is_err() {
	return None;
    }
    Some(tblids.unwrap())
}

/// Change the name of a table.
/// Needs the user ID of the requesting user.
/// Returns Some(true) if the action seems to have been successful and the requesting user is the
/// table's owner.
/// None otherwise.
pub fn rename_table(conn: &mut MysqlConnection, tblid: i32, new_name: String, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() || owner.unwrap() != uid {
	return None;
    }
    let rnm = jrtables::rename_jrtable(conn, tblid, &new_name);
    if rnm.is_err() {
	return None;
    }
    Some(true)
}

 
/// Delete a table.
/// Needs the user ID of the requesting user.
/// Returns Some(true) if the action seems to have been successful and the requesting user is the
/// table's owner.
/// None otherwise.
pub fn delete_table(conn: &mut MysqlConnection, tblid: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() || owner.unwrap() != uid {
	return None;
    }
    let dlt = jrtables::delete_jrtable(conn, tblid);
    if dlt.is_err() {
	return None;
    }
    Some(true)
}


/// Create a new table.
/// Needs the user ID of the requesting user.
/// Returns the id of the newly created table if the action seems to have been successful and the requesting user is the
/// table's owner.
/// None otherwise.
pub fn create_table(conn: &mut MysqlConnection, name: String, field_names: Vec<String>, field_types: Vec<crate::FIELDTYPE>, uid: i32) -> Option<i32> {
    if jrtables::get_tbl_by_name_uid(conn, &name, uid).is_ok() {
	return None;
    }
    if jrtables::create_jrtable(conn, &name, field_names, field_types, uid).is_err() {
	return None;
    }
    let tblid = jrtables::get_tbl_by_name_uid(conn, &name, uid);
    if tblid.is_err() {
	return None;
    }
    Some(tblid.unwrap())
}

/// Returns a User struct of a requested user if the combination of username and email are
/// consistent or both do not exist yet, in which case the user is newly created.
pub fn register_or_login(conn: &mut MysqlConnection, uname: String, mail: String) -> Option<User> {
    let mut uid = users::get_uid_email(conn, &mail);
    if uid.is_err() {
	if users::get_uid_uname(conn, &uname).is_ok() || users::create_user(conn, &uname, &mail).is_err() {
	    return None;
	}
	uid = users::get_uid_email(conn, &mail);
	if uid.is_err() {
	    return None;
	}
    }
	let uid = uid.unwrap();
	let nm = users::get_uname(conn, uid);
	if nm.is_err() || nm.unwrap() != uname {
	    return None;
	}
    Some(User { uid: uid, uname: uname, email: mail })
}

pub fn delete_user(conn: &mut MysqlConnection, uid: i32) -> Option<bool> {
    if users::delete_user(conn, uid).is_err() {
	return None;
    }
    Some(true)
}

pub fn add_row(conn: &mut MysqlConnection, tblid: i32, values: Vec<String>, uid: i32) -> Option<i32> {
    let owner = jrtables::get_owner_id(conn, tblid);
    let nrows = jrtables::get_nrows(conn, tblid);
    if nrows.is_err() || owner.is_err() || owner.unwrap() != uid {
	return None;
    }
    let nrows = nrows.unwrap() as i32;
    if jrentries::create_jrentry(conn, tblid).is_err() {
	return None;
    }
    let entryid = jrentries::get_jrentry_id(conn, tblid, nrows+1);
    if entryid.is_err() {
	return None;
    }
    let entryid = entryid.unwrap();
    let cols = jrcolumns::get_clmns_of(conn, tblid);
    if cols.is_err() {
	return None;
    }
    let cols = cols.unwrap();
    for (i,col) in cols.iter().enumerate() {
	if jrcells::create_jrcell(conn, entryid, col.id, &values[i]).is_err() {
	    return None;
	}
    }
    Some(entryid)
}

pub fn delete_row(conn: &mut MysqlConnection, tblid: i32, row_pos: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() || owner.unwrap() != uid || jrentries::delete_jrentry_relative(conn, tblid, row_pos).is_err() {
	return None;
    }
    Some(true)
}

pub fn move_row(conn: &mut MysqlConnection, tblid: i32, rowpos: i32, newpos: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() || owner.unwrap() != uid || jrentries::move_jrentry(conn, tblid, rowpos, newpos).is_err() {
	return None;
    }
    Some(true)
}

pub fn edit_row(conn: &mut MysqlConnection, tblid: i32, cells: Vec<String>, row_pos: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() || owner.unwrap() != uid {
	return None;
    }
    for (i, cell) in cells.iter().enumerate() {
	if jrcells::change_jrcell_value_relative(conn, tblid, row_pos, (i+1) as i32, cell).is_err() {
	    return None;
	}
    }
    Some(true)
}


pub fn edit_cell(conn: &mut MysqlConnection, tblid: i32, row_pos: i32, column_pos: i32, new_value: &String, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() ||
	owner.unwrap() != uid ||
	jrcells::change_jrcell_value_relative(conn, tblid, row_pos, column_pos, new_value).is_err()
    {
	return None;
    }
    Some(true)
}

pub fn move_column(conn: &mut MysqlConnection, tblid:i32, column_pos: i32, new_column_pos: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() ||
	owner.unwrap() != uid ||
	jrcolumns::move_column_relative(conn, tblid, column_pos, new_column_pos).is_err()
    {
	return None;
    }
    Some(true)
}

pub fn add_column(conn: &mut MysqlConnection, tblid: i32, name: String, clmtype: FIELDTYPE, uid: i32) -> Option<i32> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() ||
	owner.unwrap() != uid ||
	jrcolumns::create_jrcolumn(conn, tblid, name, clmtype).is_err()
    {
	return None;
    }
    let clmid = jrcolumns::get_last_column_id_of(conn, tblid);
    if clmid.is_err() {
	return None;
    }
    Some(clmid.unwrap())
}

pub fn delete_column(conn: &mut MysqlConnection, tblid: i32, column_pos: i32, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() ||
	owner.unwrap() != uid ||
	jrcolumns::delete_column_relative(conn, tblid, column_pos).is_err()
    {
	return None;
    }
    Some(true)
}

pub fn rename_column(conn: &mut MysqlConnection, tblid: i32, column_pos: i32, new_name: String, uid: i32) -> Option<bool> {
    let owner = jrtables::get_owner_id(conn, tblid);
    if owner.is_err() ||
	owner.unwrap() != uid ||
	jrcolumns::rename_column_relative(conn, tblid, column_pos, new_name).is_err()
    {
	return None;
    }
    Some(true)
}