//Copyright (c) 2007 Joshua R. Rodgers

//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:

//The above copyright notice and this permission notice shall be included in
//all copies or substantial portions of the Software.

//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//THE SOFTWARE.

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace Bone
{
    partial class Handle
    {
        /// <summary>
        /// Adds a contact to the internal contact list.
        /// </summary>
        /// <param name="contact">Name of the contact.</param>
        /// <returns>true on failure.</returns>
        public bool AddContact(string contact)
        {
            return Importer.bone_addcontact(bHandle, contact);
        }

        /// <summary>
        /// Requests an email change.
        /// Causes disconnection and a new password is sent to verify the e-mail.
        /// </summary>
        /// <param name="newEmail">The email address to change to.</param>
        /// <returns>true on failure.</returns>
        public bool ChangeEmail(string newEmail)
        {
            return Importer.bone_changeemail(bHandle, newEmail);
        }

        /// <summary>
        /// Creates a new user using the name and email provided.
        /// </summary>
        /// <param name="user">The name of the user to create.</param>
        /// <param name="email">Email address to send the password to.</param>
        /// <returns>true on failure.</returns>
        public bool CreateUser(string user, string email)
        {
            if (Utility.handleDictionary.ContainsKey(bHandle))
                Utility.handleDictionary.Remove(bHandle);

            bHandle = Importer.bone_create();
            Utility.handleDictionary.Add(bHandle, this);

            return Importer.bone_createuser(bHandle, user, email);
        }

        /// <summary>
        /// Removes a contact from the internal contacts list.
        /// </summary>
        /// <param name="contact">Name of the contact.</param>
        /// <returns>true on failure.</returns>
        public bool DeleteContact(string contact)
        {
            return Importer.bone_delcontact(bHandle, contact);
        }

        /// <summary>
        /// Invites a user to the specified channel.
        /// </summary>
        /// <param name="channelName">Name of the channel to invite the user to.</param>
        /// <param name="name">Name of the user to invite to the channel.</param>
        /// <returns>true on failure.</returns>
        public bool InviteUser(string channelName, string name)
        {
            return Importer.bone_inviteuser(bHandle, channelName, name);
        }

        /// <summary>
        /// Determines wheter or not if a user is online.
        /// </summary>
        /// <param name="name">Name of the user to check the online status of.</param>
        /// <returns>true on failure.</returns>
        public bool IsOnline(string name)
        {
            return Importer.bone_isonline(bHandle, name);
        }

        /// <summary>
        /// Causes the current Handle to join the specified channel.
        /// </summary>
        /// <param name="channelName">Name of the channel to join.</param>
        /// <returns>true on failure.</returns>
        public bool JoinChannel(string channelName)
        {
            return Importer.bone_joinchannel(bHandle, channelName, 0, "");
        }

        /// <summary>
        /// Causes the current Handle to join the specified channel.
        /// </summary>
        /// <param name="channelName">Name of the channel to join,</param>
        /// <param name="password">Password to use when joining the channel.</param>
        /// <returns>true on failure.</returns>
        public bool JoinChannel(string channelName, string password)
        {
            return Importer.bone_joinchannel(bHandle, channelName, 0, password);
        }

        /// <summary>
        /// Causes the current Handle to join the specified channel.
        /// </summary>
        /// <param name="channelName">Name of the channel to join,</param>
        /// <param name="inviteOnly">Specifies if this channel is invite only.</param>
        /// <returns>true on failure.</returns>
        public bool JoinChannel(string channelName, bool inviteOnly)
        {
            return Importer.bone_joinchannel(bHandle, channelName, (inviteOnly ? 1 : 0), "");
        }

        /// <summary>
        /// Causes the current Handle to leave the specified channel.
        /// </summary>
        /// <param name="channelName">Name of the channel to leave</param>
        /// <returns>true on failure.</returns>
        public bool LeaveChannel(string channelName)
        {
            return Importer.bone_leavechannel(bHandle, channelName);
        }

        /// <summary>
        /// Logs the current handle into the server for normal operation.
        /// </summary>
        /// <param name="user">User name to use when logging in.</param>
        /// <param name="password">Password to use when logging in.</param>
        /// <returns>true on failure.</returns>
        public bool Login(string user, string password)
        {
            if (Utility.handleDictionary.ContainsKey(bHandle))
                Utility.handleDictionary.Remove(bHandle);

            bHandle = Importer.bone_create();
            Utility.handleDictionary.Add(bHandle, this);

            return Importer.bone_login(bHandle, user, password);
        }

        /// <summary>
        /// Modifies the user's profile.
        /// </summary>
        /// <param name="user">Name of the user to modify.</param>
        /// <param name="password">New password.</param>
        /// <param name="email">New email address.</param>
        /// <param name="userType">Type of the user.</param>
        /// <param name="isDisabled">Enable/Disable the user.</param>
        /// <returns>true on failure.</returns>
        public bool ModifyUserProfile(string user, string password, string email, int userType, int isDisabled)
        {
            return Importer.bone_modifyuserprofile(bHandle, user, password, email, userType, isDisabled);
        }

        /// <summary>
        /// Pings the specified user.
        /// </summary>
        /// <param name="user">Name of the user to ping.</param>
        /// <returns>true on failure.</returns>
        public bool PingUser(string user)
        {
            return Importer.bone_pinguser(bHandle, user);
        }

        /// <summary>
        /// Requests a list of channels.
        /// </summary>
        /// <returns>true on failure.</returns>
        public bool RequestChannelList()
        {
            return Importer.bone_reqchannellist(bHandle);
        }

        /// <summary>
        /// Requests the password of a user.
        /// </summary>
        /// <param name="user">User name to request password of.</param>
        /// <param name="email">Email of the user.</param>
        /// <returns></returns>
        public bool RequestPassword(string user, string email)
        {
            if (Utility.handleDictionary.ContainsKey(bHandle))
                Utility.handleDictionary.Remove(bHandle);

            bHandle = Importer.bone_create();
            Utility.handleDictionary.Add(bHandle, this);

            return Importer.bone_reqpassword(bHandle, user, email);
        }

        /// <summary>
        /// Requests a profile about a user.
        /// </summary>
        /// <param name="user">Name of the user.</param>
        /// <returns>true on failure.</returns>
        public bool ReqestUserProfile(string user)
        {
            return Importer.bone_requserprofile(bHandle, user);
        }

        /// <summary>
        /// Sends a text message to the specified target.
        /// </summary>
        /// <param name="target">Target (user or channel) to send the message to.</param>
        /// <param name="message">Message to be sent.</param>
        /// <returns>true on failure.</returns>
        public bool SendText(string target, string message)
        {
            return Importer.bone_sendtext(bHandle, target, message);
        }

        /// <summary>
        /// Sends a text message to the specified target.
        /// </summary>
        /// <param name="target">Target (user or channel) to send the message to.</param>
        /// <param name="format">Message to be sent.</param>
        /// <param name="args">Variable number of arguments to be used by the format string.</param>
        /// <returns>true on failure.</returns>
        public bool SendText(string target, string format, params object[] args)
        {
            StringBuilder strBuilder = new StringBuilder();
            strBuilder.AppendFormat(format, args);
            return Importer.bone_sendtext(bHandle, target, strBuilder.ToString());
        }

        /// <summary>
        /// Requests an update to the contacts list stored internally.
        /// </summary>
        /// <returns>true on failure.</returns>
        public bool UpdateContacts()
        {
            return Importer.bone_updatecontacts(bHandle);
        }

        /// <summary>
        /// Disconnects the current handle from the server.
        /// </summary>
        /// <returns>true on failure.</returns>
        public bool Disconnect()
        {
            return Importer.bone_destroy(bHandle);
        }
    }
}