import time
import datetime
import dateutil
import json
import bot_engine.const as const
import bot_engine.util as util
# import bot_engine.utility.kms as kms
from bot_engine.log import log as bot_log
from bot_engine.bot_base import BotBase
from bot_engine.request.core import BotCoreRequest
# from bot_engine.request.rocket_chat import RocketChatRequest
from bot_engine.state import State
from bot_engine.queue import BotQueue
from bot_engine.model import (User, BotProfile, GeneralProfile, BotReply,
                              Lookupgroup, Lookup, UserProfile, ActivityLog)


class BotUpdate(BotBase):
    """
    Class for querying user, create user, and updating user
    """
    def __init__(self,
                 file_config='config/update.conf',
                 log=None):
        """

        Args:
            log (Logger)
            file_config (string)
        """
        BotBase.__init__(self, log=log, file_config=file_config)
        self.request = BotCoreRequest(log=self.log)
        # self.rocket_chat = RocketChatRequest()

    def get_user_by_id(self, uid):
        """

        Args:
            uid (int): user id

        Returns:
            bot_engine.model.User: response User object
        """
        return self.request.get_user(uid=uid)

    def get_user(self, message):
        """
        Get user's data from bot database by message or callback query.

        Args:
            message (bot_engine.model.BotMessage)

        Returns:
            bot_engine.model.User: correspond user based on message's user id
        """
        self.log.debug('GET USER')
        user = None

        if message.from_telegram_uid:
            telegram_uid = message.from_telegram_uid
            user = self.request.get_user_by_telegram_uid(telegram_uid)
            if user:
                user.bot_profile.last_active_platform = const.PLATFORM_TELEGRAM

        if message.from_line_uid:
            line_uid = message.from_line_uid
            user = self.request.get_user_by_line_uid(line_uid)
            if user:
                user.bot_profile.last_active_platform = const.PLATFORM_LINE

        if message.from_facebook_uid:
            facebook_uid = message.from_facebook_uid
            user = self.request.get_user_by_facebook_uid(facebook_uid)
            if user:
                user.bot_profile.last_active_platform = const.PLATFORM_FACEBOOK

        if message.from_rocketchat_uid:
            rocketchat_uid = message.from_rocketchat_uid
            user = self.request.get_user_by_rocketchat_uid(rocketchat_uid)
            if user:
                user.bot_profile.last_active_platform = const.PLATFORM_RC

        if message.from_mobile_uid:
            mobile_uid = message.from_mobile_uid
            user = self.request.get_user_by_mobile_uid(mobile_uid)
            if user:
                user.bot_profile.last_active_platform = const.PLATFORM_MOBILE

        return user

    def get_engagement(self, user_id):
        """

        Args:
            user_id (int)

        Returns:
            bot_engine.model.Engagement:
        """
        engagement = self.request.get_last_active_engagement(user_id)
        return engagement

    def create_user(self, message):
        """
        Instantiate new user with provided uid, save to database

        Args:
            message (bot_engine.model.BotMessage)

        Returns:
            bot_engine.model.User: created user
        """
        self.log.debug('CREATE USER')
        first_name = None
        last_name = None
        last_active_platform = None
        if message.from_telegram_uid:
            telegram_uid = message.from_telegram_uid
            first_name = message.from_first_name
            last_name = message.from_last_name
            last_active_platform = const.PLATFORM_TELEGRAM

        if message.from_line_uid:
            line_uid = message.from_line_uid
            first_name = message.from_first_name
            last_name = message.from_last_name
            last_active_platform = const.PLATFORM_LINE
            picture_profile = message.photo_profile

        if message.from_facebook_uid:
            facebook_uid = message.from_facebook_uid
            first_name = message.from_first_name
            last_name = message.from_last_name
            last_active_platform = const.PLATFORM_FACEBOOK

        if message.from_rocketchat_uid:
            rocketchat_uid = message.from_rocketchat_uid
            first_name = message.from_first_name
            last_name = message.from_last_name
            last_active_platform = const.PLATFORM_RC

        if message.from_mobile_uid:
            mobile_uid = message.from_mobile_uid
            first_name = message.from_first_name
            last_name = message.from_last_name
            last_active_platform = const.PLATFORM_MOBILE
            device_token = message.from_device_token
        # ADD QUERY FROM LINE
        # if message.telegram:
        #     telegram_uid = message.telegram.message.from_user.id
        #     first_name = message.telegram.message.from_user.first_name
        #     last_name = message.telegram.message.from_user.last_name

        user = User()
        # Bot Profile
        bot_profile = BotProfile()
        if message.from_telegram_uid:
            bot_profile.telegram_uid = telegram_uid
        if message.from_line_uid:
            bot_profile.line_uid = line_uid
        if message.from_facebook_uid:
            bot_profile.facebook_uid = facebook_uid
        if message.from_rocketchat_uid:
            bot_profile.rocketchat_uid = rocketchat_uid
        if message.from_mobile_uid:
            bot_profile.mobile_uid = mobile_uid

        bot_profile.language = const.LANGUAGE_ID
        bot_profile.current_state_id = 1
        bot_profile.last_active_platform = last_active_platform

        # General Profile
        general_profile = GeneralProfile()
        general_profile.first_name = first_name
        general_profile.last_name = last_name
        general_profile.join_date = datetime.datetime.now()

        name = ' '.join([first_name or '', last_name or ''])
        if last_active_platform == const.PLATFORM_LINE:
            general_profile.picture = picture_profile
        if last_active_platform == const.PLATFORM_MOBILE:
            general_profile.device_token = device_token

        # User Profile
        user_profile = UserProfile()
        # user_profile.rc_user_name = self.config.get('rocket_chat', 'USERNAME_PATTERN').format(id='0')
        # user_profile.rc_email = self.config.get('rocket_chat', 'EMAIL_PATTERN').format(id='0')
        #
        # raw_password = self.config.get('rocket_chat', 'PASSWORD_PATTERN')

        # encrypt password
        # encrypted_data = kms.encrypt_text(raw_password)
        # user_profile.rc_password = encrypted_data
        # user_profile.rc_password = "ga bisa encrypt"
        # user_profile.ciphertext = ciphertext

        user.bot_profile = bot_profile
        user.general_profile = general_profile
        user.user_profile = user_profile

        if user:
            user = self.request.post_user(user)

        # Create rocket chat user
        # user.user_profile.rc_user_name = self.config.get('rocket_chat', 'USERNAME_PATTERN').format(id=user.id)
        # user.user_profile.rc_email = self.config.get('rocket_chat', 'EMAIL_PATTERN').format(id=user.id)
        #
        # json_user = self.rocket_chat.create_user_person_service(name,
        #                                                         user.user_profile.rc_email,
        #                                                         raw_password,
        #                                                         user.user_profile.rc_user_name)

        if user:
            user = self.request.put_user(user)

        return user

    def save_user(self, user):
        """
        Save user object into database

        Args:
            user (bot_engine.model.User)

        Returns:
            bot_engine.model.User: response User objectjson

        """
        return self.request.put_user(user)

    def process(self, message, user=None):
        """
        Get message from message instance then find the user, if not found
        register new user to database

        Args:
            message (bot_engine.model.BotMessage)

        Returns:
            bot_engine.model.User: updated user
            bot_engine.model.BotReply: bot engine reply object consist of replies
                and input replies
        """
        start_time = time.time()
        self.log.info('START UPDATE: message: %s', message)
        if user is None:
            # get user and create new user
            user = self.get_user(message)
            if user is None:
                user = self.create_user(message)
        self.log.debug('CURRENT USER: %s', user)

        # get engagement
        # engagement = self.get_engagement(user.id)

        # Save log from user

        # if user.get_attr('session.commerce_chat_id'):
        #     chat_partner = user.get_attr('session.commerce_chat_id')
        chat_partner = None
        if user.get_attr('session.ecommerce.commerce_chat_id'):
            chat_partner = user.get_attr('session.ecommerce.commerce_chat_id')
        message_to = None
        if user.get_attr('session.ecommerce.leave_message_to'):
            message_to = user.get_attr('session.ecommerce.leave_message_to')
            user.set_attr('session.ecommerce.leave_message_to', None)
            is_read = False

        self.save_log(from_user=user.id,
            state_id=user.bot_profile.current_state_id,
            message=message.to_dict(),
            chat_partner=chat_partner,
            message_to=message_to,
            is_read=False )

        # process next state and return updated user
        state = State(log=self.log)
        user, bot_reply = state.process(user, message)

        # self.save_engagement(engagement)

        # Save log from botengine
        self.save_log_from_bot(user, bot_reply)

        # Update user memory
        self.log.debug('UPDATED USER: %s', user)
        self.save_user(user)
        self.log.info("--- bot_update.process: %s seconds ---", (time.time() - start_time))
        return user, bot_reply

    def process_queue(self, user_id=None, user=None, alert_only=False):
        """
        Get user from user_id then process to queue

        Args:
            user_id (int)

        Returns:
            bot_engine.model.User: updated user
            bot_engine.model.BotReply: bot engine reply object consist of replies
                and input replies
        """
        start_time = time.time()
        self.log.info('START PROCESS QUEUE: user_id: %s', user_id)

        # get user and proces queue
        if user_id is not None:
            user = self.get_user_by_id(user_id)

        state = State(log=self.log)

        user, bot_reply = state.process_queue(user, alert_only)

        # Save log from botengine
        self.save_log_from_bot(user, bot_reply)

        # Update user memory
        self.log.debug('UPDATED USER: %s', user)
        self.save_user(user)
        self.log.info("--- bot_update.process_queue: %s seconds ---", (time.time() - start_time))

        return user, bot_reply

    def save_log(self, from_user=None, to_user=None, state_id=None, message=None, chat_partner=None, message_to=None, is_read=None):
        """
        Log user message or bot message to database

        Args:
            from_user (int):
            to_user (int):
            state_id (int):
            message (dict):
            message_to (int):

        Returns:
            bot_engine.model.ActivityLog
        """
        timestamp = util.date_now()
        activity_log = ActivityLog(from_user=from_user,
            to_user=to_user, state_id=state_id, timestamp=timestamp,
            message=message, chat_partner=chat_partner, message_to=message_to, is_read=is_read)
        activity_log = self.request.post_activity_logs(activity_log=activity_log)
        return activity_log

    def save_log_from_bot(self, user, bot_reply):
        """

        Args:
            user (bot_engine.model.User)
            bot_reply (bot_engine.model.BotReply)

        Returns:
            bot_engine.model.ActivityLog

        """

        # immediate fix to handle binary files: Remove them!
        for rep in bot_reply.replies:
            try:
                result = json.dumps(rep)
            except TypeError as e:
                bot_reply.replies.remove(rep)

        # if user.get_attr('session.commerce_chat_id'):
        #     chat_partner = user.get_attr('session.commerce_chat_id')
        chat_partner = None
        if user.get_attr('session.ecommerce.commerce_chat_id'):
            chat_partner = user.get_attr('session.ecommerce.commerce_chat_id')

        return self.save_log(to_user=user.id,
            state_id=user.bot_profile.current_state_id,
            message=bot_reply.replies,
            chat_partner=chat_partner)

    def save_engagement(self, engagement):
        return self.request.put_engagements(engagement)

def get_user(message, user=None):
    """
    Get message from message instance then find the user, if not found
    register new user to database

    Args:
        message (bot_engine.model.BotMessage)

    Returns:
        bot_engine.model.User: updated user
        bot_engine.model.BotReply: bot engine reply object consist of replies
            and input replies
    """
    update = BotUpdate(log=bot_log)
    bot_log.debug('START UPDATE: message: %s', message)

    if user is None:
        # get user and create new user
        user = update.get_user(message)
        if user is None:
            user = update.create_user(message)
    # bot_log.debug('CURRENT USER: %s', user)

    # Save log from user
    chat_partner = None
    message_to = None
    is_read = None
    if user.get_attr('session.ecommerce.leave_message_to'):
        message_to = user.get_attr('session.ecommerce.leave_message_to')
        user.set_attr('session.ecommerce.leave_message_to', None)
        is_read = False
    # if user.get_attr('session.commerce_chat_id'):
    #     chat_partner = user.get_attr('session.commerce_chat_id')
    if user.get_attr('session.ecommerce.commerce_chat_id'):
        chat_partner = user.get_attr('session.ecommerce.commerce_chat_id')

    update.save_log(from_user=user.id,
                    state_id=user.bot_profile.current_state_id,
                    message=message.to_dict(),
                    chat_partner=chat_partner,
                    is_read = is_read,
                    message_to=message_to)
    return user

def get_user_by_id(uid):
    """
    Args:
        uid (int): user id

    Returns:
        bot_engine.model.User: response User object
    """
    update = BotUpdate(log=bot_log)
    return update.request.get_user(uid=uid)