extern crate purple_sys;
extern crate glib_sys;
extern crate libc;
#[macro_use]
extern crate lazy_static;

/*
mod pointer;
mod server;
mod user;
mod chatroom;
mod message;
*/
use std::os::raw::{c_void, c_char};
use std::ptr::null_mut;
use std::boxed::Box;
use std::ffi::CString; // CStr
//use std::sync::RwLock;

use purple_sys::*;
use purple_sys::PurpleType;
//use purple_sys::PurpleConnectionState;
use purple_sys::PurpleStatusPrimitive;
//use purple_sys::PurpleRoomlistFieldType;
//use message::*;
//use pointer::Pointer;
//use server::ACCOUNT;
//use server::{send_im, send_chat, find_blist_chat, find_chat_token};

use glib_sys::{GHashTable, GList};

const TRUE: i32 = 1;
const FALSE: i32 = 0;

lazy_static!{
    // static ref PLUGIN: RwLock<Pointer> = RwLock::new(Pointer::new());
    static ref ICON_FILE: CString = CString::new("delta").unwrap();
    // static ref DELTA_CATEGORY: CString = CString::new("Delta Chat").unwrap();
}

fn append_item(list: *mut GList, item: *mut c_void) -> *mut GList {
    unsafe {
        glib_sys::g_list_append(list as *mut glib_sys::GList, item as *mut libc::c_void) as
            *mut GList
    }
}

extern "C" fn list_icon(_: *mut PurpleAccount, _: *mut PurpleBuddy) -> *const c_char {
    ICON_FILE.as_ptr()
}

extern "C" fn status_types(_: *mut PurpleAccount) -> *mut GList {

    let mut list: *mut GList = null_mut();

    let available = CString::new("available").unwrap();
    let available_name = CString::new("Available").unwrap();
    let offline = CString::new("offline").unwrap();
    let offline_name = CString::new("Offline").unwrap();
    let nick = CString::new("nick").unwrap();

    let status = unsafe {
        purple_status_type_new_with_attrs(
            PurpleStatusPrimitive::PURPLE_STATUS_AVAILABLE,
            available.as_ptr(),
            available_name.as_ptr(),
            TRUE,
            TRUE,
            FALSE,
            nick.as_ptr(),
            nick.as_ptr(),
            purple_value_new(PurpleType::PURPLE_TYPE_STRING),
            null_mut() as *mut c_void,
        )
    };
    list = append_item(list, status as *mut c_void);

    let status = unsafe {
        purple_status_type_new_with_attrs(
            PurpleStatusPrimitive::PURPLE_STATUS_OFFLINE,
            offline.as_ptr(),
            offline_name.as_ptr(),
            TRUE,
            TRUE,
            FALSE,
            nick.as_ptr(),
            nick.as_ptr(),
            purple_value_new(PurpleType::PURPLE_TYPE_STRING),
            null_mut() as *mut c_void,
        )
    };
    list = append_item(list, status as *mut c_void);

    list
}

unsafe extern "C" fn login(account: *mut PurpleAccount) {
    println!("account: {:?}", account);
}

extern "C" fn chat_info(_: *mut PurpleConnection) -> *mut GList {

    let list: *mut GList = null_mut();

    list
}

unsafe extern "C" fn join_chat(gc: *mut PurpleConnection, components: *mut GHashTable) {
    println!("join_chat: {:?}, {:?}", gc, components);
}

extern "C" fn chat_info_defaults(_: *mut PurpleConnection, _: *const c_char) -> *mut GHashTable {

    let table: *mut GHashTable = null_mut();

    table
}

extern "C" fn close(_: *mut PurpleConnection) {}

extern "C" fn buddy_list(gc: *mut PurpleConnection) -> *mut PurpleRoomlist {
    let buddies = unsafe { purple_roomlist_new(purple_connection_get_account(gc)) };

    buddies
}

extern "C" fn callback(_plugin: *mut PurplePlugin) -> i32 {
    TRUE
}

// extern "C" fn action_cb(_: *mut PurplePluginAction) {
//
// }

extern "C" fn actions(_: *mut PurplePlugin, _: *mut c_void) -> *mut GList {

    let list: *mut GList = null_mut();

    list
}

#[no_mangle]
pub extern "C" fn purple_init_plugin(plugin: *mut PurplePlugin) -> i32 {
    // save plugin pointer
    // PLUGIN.write().unwrap().set(plugin as *mut c_void);

    let id = CString::new("prpl-delta").unwrap();
    let name = CString::new("Delta Chat").unwrap();
    let version = CString::new("0.1.0").unwrap();
    let summary = CString::new("Delta Chat is an email-based instant messaging solution").unwrap();
    let description = CString::new("See https://delta.chat for more information").unwrap();
    let author = CString::new("Nick Thomas <delta@ur.gs>").unwrap();
    let home_page = CString::new("https://delta.chat").unwrap();

    let mut info = Box::new(PurplePluginInfo::new());
    let mut extra_info = Box::new(PurplePluginProtocolInfo::new());

    unsafe {

        extra_info.list_icon = Some(list_icon);
        extra_info.status_types = Some(status_types);
        extra_info.login = Some(login);
        extra_info.close = Some(close);
        extra_info.roomlist_get_list = Some(buddy_list);
        extra_info.chat_info = Some(chat_info);
        extra_info.chat_info_defaults = Some(chat_info_defaults);
        //extra_info.chat_send = Some(send_chat);
        extra_info.join_chat = Some(join_chat);
        //extra_info.find_blist_chat = Some(find_blist_chat);
        //extra_info.send_im = Some(send_im);

        info.id = id.into_raw();
        info.name = name.into_raw();
        info.version = version.into_raw();
        info.summary = summary.into_raw();
        info.description = description.into_raw();
        info.author = author.into_raw();
        info.homepage = home_page.into_raw();
        info.load = Some(callback);
        info.actions = Some(actions);
        info.extra_info = Box::into_raw(extra_info) as *mut c_void;

        (*plugin).info = Box::into_raw(info);
    };

    unsafe { purple_plugin_register(plugin) }
}