/*****************************************************************************
*  bg_SlackUtils
*
*  Utils class for Slack operations
*
*  Author:     Thomas Packer - BrightGen Ltd
*  Date:       13/06/2018
*  Changes:    Craig Platt - 16/07/2018
*			   Added messageText variable and call to bg_SlackMessageUtils.setMessageMentions()
*****************************************************************************/

public class bg_SlackUtils
{
    // A method to process slack channels
    public static void processSlackChannels()
    {
        // Get slack channels
        HttpResponse response = bg_SlackAPIUtils.getAllSlackChannels('300');

        // Check we have a response
        if (response != null)
        {
            // Get response body
            String responseBody = response.getBody();

            // Get slack channels
            bg_Slack_JSON.bg_SlackChannelResponse_JSON slackChannelResponse = bg_JSONUtils.deserializeSlackChannelResults(responseBody);

            // Check we have slack channels
            if (slackChannelResponse != null)
            {
                List<Slack_Channel__c> channels = new List<Slack_Channel__c>();

                // Create slack channel records
                for (bg_Slack_JSON.bg_SlackChannel_JSON channel : slackChannelResponse.channels)
                {
                    channels.add(new Slack_Channel__c(Channel_Id__c = channel.Id, Name = channel.name));
                }

                // If we have slack channels to create/update, then do so
                if (!channels.isEmpty())
                {
                    try
                    {
                        upsert channels Channel_Id__c;
                    }
                    catch(DmlException e)
                    {
                        System.debug(LoggingLevel.ERROR, '***** DmlException - ' + e.getDmlMessage(0));
                    }
                    catch(Exception e)
                    {
                        System.debug(LoggingLevel.ERROR, '***** Exception - ' + e.getMessage());
                    }
                }
            }
        }
    }

    // A method to process slack messages
    public static void processSlackMessages(String channelId)
    {
        // Get slack messages
        HttpResponse response = bg_SlackAPIUtils.getSlackFeed(channelId);

        // Check we have a response
        if (response != null)
        {
            // Get response body
            String responseBody = response.getBody();

            // Get slack messages
            bg_Slack_JSON.bg_SlackMessageResponse_JSON slackMessageResponse = bg_JSONUtils.deserializeSlackMessageResults(responseBody);

            // Check we have slack messages
            if (slackMessageResponse != null)
            {
                // Get slack chanel Salesforce record that the messages belong to
                Slack_Channel__c slackChannel = bg_SlackChannelUtils.getSlackChannelByChannelId(channelId);

                // Check we have a slack channel
                if (slackChannel != null)
                {

                    List<Slack_Message__c> messages = new List<Slack_Message__c>();

                    // Create slack message records
                    for (bg_Slack_JSON.bg_SlackMessage_JSON message : slackMessageResponse.messages)
                    {
                        // Format slack timestamp so we can convert into a valid DateTime
                        String unixTimestamp = message.ts;
                        String formattedUTX = unixTimestamp.substring(0, unixTimestamp.indexOf('.')).rightPad(13, '0');

                        DateTime timestamp = DateTime.newInstance(Long.valueOf(formattedUTX));

                        // Create slack message id
                        String slackMessageId = unixTimestamp.remove('.') + message.user;

                        messages.add(new Slack_Message__c(Message__c = message.text, Slack_Channel__c = slackChannel.Id, Slack_User_Id__c = message.user, Timestamp__c = timestamp, Slack_Message_Id__c = slackMessageId.toUpperCase()));
                    }

                    // If we have slack messages to insert/update, then do so
                    if (!messages.isEmpty())
                    {
                        try
                        {
                            upsert messages Slack_Message_Id__c;
                        }
                        catch(DmlException e)
                        {
                            System.debug(LoggingLevel.ERROR, '***** DmlException - ' + e.getDmlMessage(0));
                        }
                        catch(Exception e)
                        {
                            System.debug(LoggingLevel.ERROR, '***** Exception - ' + e.getMessage());
                        }
                    }
                }
            }
        }
    }

    // A method to process a slack user
    public static void processSlackUser()
    {

    }

    // A method to process a slack team
    public static void processSlackTeam()
    {
        // Get slack team
        HttpResponse response = bg_SlackAPIUtils.getSlackTeam();

        // Check we have a response
        if (response != null)
        {
            // Get response body
            String responseBody = response.getBody();

            // Get slack messages
            bg_Slack_JSON.bg_SlackTeamResponse_JSON slackTeamResponse = bg_JSONUtils.deserializeSlackTeamResults(responseBody);

            // Check we have slack messages
            if (slackTeamResponse != null)
            {
                List<Slack_User__c> users = new List<Slack_User__c>();

                // Create slack User records
                for (bg_Slack_JSON.bg_SlackTeamMember_JSON member : slackTeamResponse.members)
                {
                    users.add(new Slack_User__c(Slack_User_Id__c = member.id, Slack_Avatar_Photo_URL__c = member.profile.image_48, Slack_Real_Name__c = member.profile.real_name_normalized, Slack_Display_Name__c = member.profile.display_name_normalized));
                }

                // If we have slack users to insert/update, then do so
                if (!users.isEmpty())
                {
                    try
                    {
                        upsert users Slack_User_Id__c;
                    }
                    catch(DmlException e)
                    {
                        System.debug(LoggingLevel.ERROR, '***** DmlException - ' + e.getDmlMessage(0));
                    }
                    catch(Exception e)
                    {
                        System.debug(LoggingLevel.ERROR, '***** Exception - ' + e.getMessage());
                    }
                }
            }
        }
    }

    /************************************************************************
                                    WRAPPERS
    *************************************************************************/

    // Slack channel wrapper class
    public class bg_SlackChannelWrapper
    {
        // bg_SlackChannelWrapper public members
        public String channelId;
        public String channelName;
        public String formattedLastRefreshDate;
        public String formattedLastRefreshTime;

        public DateTime lastRefreshDate;

        public List<bg_SlackActionWrapper> actions;

        public void initializeWrapper(String channelId, String channelName, DateTime lastRefreshDate)
        {
            this.channelId = channelId;
            this.channelName = channelName;

            this.lastRefreshDate = lastRefreshDate;

            actions = new List<bg_SlackActionWrapper>();

            setRefreshDateTime(lastRefreshDate);
        }

        // A method to build channel messages
        public void setMessages(Map<Id, Slack_Message__c> slackMessages, Map<String, Slack_User__c> slackUsersBySlackUserId)
        {
            // Clearing out existing actions
            if (actions.size() > 0)
            {
                actions.clear();
            }

            Map<String, bg_SlackActionWrapper> actionsByDate = new Map<String, bg_SlackActionWrapper>();

            String previousMessageSenderId;
            DateTime previousMessageSendTime;
            Slack_Message__c previousMessage;
            boolean multiMessage = false;
            boolean previousMultiMessageValue = false;
            Integer counter;

            // Build up channel actions
            for (Slack_Message__c message : slackMessages.values())
            {
                String formatDate = message.Timestamp__c.format('dd/MM/yy');

                bg_SlackActionWrapper actionWrapper;

                // Check we do not already have a bg_SlackActionWrapper in memory for this date
                // If not, create one
                if (!actionsByDate.containsKey(formatDate))
                {
                    String dateDisplayString;

                    Date today = Date.today();
                    Date yesterday = Date.today().addDays(-1);

                    // Calculate if message date is today or yesterday. Otherwise just display the date.
                    if (today.format() == message.Timestamp__c.format('dd/MM/yyyy'))
                    {
                        dateDisplayString = 'Today';
                    }
                    else if(yesterday.format() == message.Timestamp__c.format('dd/MM/yyyy'))
                    {
                        dateDisplayString = 'Yesterday';
                    }
                    else
                    {
                        dateDisplayString = formatDate;
                    }

                    actionWrapper = new bg_SlackActionWrapper(dateDisplayString);
                    actionsByDate.put(formatDate, actionWrapper);
                    actions.add(actionWrapper);
                }
                else
                {
                    actionWrapper = actionsByDate.get(formatDate);
                }

                // Get slack user record by slack user id
                Slack_User__c slackUser = slackUsersBySlackUserId.get(message.Slack_User_Id__c);

				String messageText;

				// Check if message contains a mention
				if(message.Message__c.contains('@'))
				{
					messageText = bg_SlackMessageUtils.setMessageMentions(message.Message__c, slackUsersBySlackUserId);
				}
				else
				{
					messageText = message.Message__c;
				}

				String displayName;

				if (slackUser.slack_Display_Name__c != null)
				{
					displayName = slackUser.Slack_Display_Name__c;
				}
				else
				{
					displayName = slackUser.Slack_Real_Name__c;
				}

				if(previousMessage != null)
				{
					if(previousMessage.Slack_User_Id__c != null && previousMessage.Timestamp__c != null)
					{
						if(message.Slack_User_Id__c.Equals(previousMessage.Slack_User_Id__c))
						{

							if(message.Timestamp__c.getTime() - previousMessage.Timestamp__c.getTime() < 300000)
							{
								multiMessage = true;
								System.debug(LoggingLevel.ERROR, '****CP previousMessage text before current text is applied= ' + previousMessage.Message__c);
								previousMessage.Message__c += '\n' + message.Message__c;
								System.debug(LoggingLevel.ERROR, '****CP updatedMessage = ' + previousMessage);
								System.debug(LoggingLevel.ERROR, '****CP updatedMessage text = ' + previousMessage.Message__c);
							}
							else
							{
								multiMessage = false;
							}
							//check previous send time is within 5 minutes and create a new wrapper if they are.
							//Need to create a multipleMessageWrapper - maybe
							//if time of second date in millis - previousdate in millis is less than 300000, they are within 5 minutes.
							//add a css tooltip to the messages with the time.
						}
						else
						{
							multiMessage = false;
						}
					}

				}
				else
				{
					multiMessage = false;
				}

				if(previousMessage != null)
				{

				}

				System.debug(LoggingLevel.ERROR, 'mutlimessage = ' + multimessage);
				System.debug(LoggingLevel.ERROR, 'previousMultiMessageValue = ' + previousMultiMessageValue);
				if(!multiMessage && previousMultiMessageValue)
				{
					System.Debug(LoggingLevel.ERROR, '&&&&&CP multiMessage is false and previous value was true, creating multi message');
					System.Debug(LoggingLevel.ERROR, '&&&&&CP message to be created = ' + PreviousMessage.Message__c);
					// Create channel messages and add it to the action wrapper messages collection
                		actionWrapper.messages.add(new bg_SlackMessageWrapper(previousMessage.Slack_User_Id__c, displayName, previousMessage.Message__c, previousMessage.Timestamp__c, slackUser.Slack_Avatar_Photo_URL__c));

                		if(!message.Slack_User_Id__c.Equals(previousMessage.Slack_User_Id__c))
                		{
                			actionWrapper.messages.add(new bg_SlackMessageWrapper(message.Slack_User_Id__c, displayName, messageText, message.Timestamp__c, slackUser.Slack_Avatar_Photo_URL__c));
                		}

					previousMessage = message;

				}
				else if(!multiMessage && !previousMultiMessageValue)
				{
					System.Debug(LoggingLevel.ERROR, '&&&&&CP multiMessage is false and previous value was false, creating normal message');
					actionWrapper.messages.add(new bg_SlackMessageWrapper(message.Slack_User_Id__c, displayName, messageText, message.Timestamp__c, slackUser.Slack_Avatar_Photo_URL__c));
					//previousMessage = message;
				}

                // Create channel messages and add it to the action wrapper messages collection
                //actionWrapper.messages.add(new bg_SlackMessageWrapper(message.Slack_User_Id__c, displayName, messageText, message.Timestamp__c, slackUser.Slack_Avatar_Photo_URL__c));


                previousMultiMessageValue = multiMessage;
                //previousMessageSendTime = message.Timestamp__c;
            }
        }

        // A method to format the last refresh date/time
        private void setRefreshDateTime(DateTime lastRefreshDate)
        {
            if (lastRefreshDate != null)
            {
                formattedLastRefreshDate = lastRefreshDate.format('dd/MM/yy');
                formattedLastRefreshTime = lastRefreshDate.format('h:mm a');
            }
        }
    }

    // Slack action wrapper class
    public class bg_SlackActionWrapper
    {
        // bg_SlackActionWrapper public members
        public String formatDate;

        public List<bg_SlackMessageWrapper> messages;

        public bg_SlackActionWrapper(String formatDate)
        {
            this.formatDate = formatDate;

            messages = new List<bg_SlackMessageWrapper>();
        }
    }

    // Slack messages wrapper class
    public class bg_SlackMessageWrapper
    {
        // bg_SlackMessageWrapper public members
        public String userId;
        public String realName;
        public String firstName;
        public String lastName;
        public String message;
        public String formattedDate;
        public String formattedTime;
        public String avatarUrl;

        // bg_SlackMessageWrapper private members
        private DateTime timestamp;

        private Date postDate;

        private Time postTime;

        public bg_SlackMessageWrapper(String userId, String realName, String message, DateTime timestamp, String avatarUrl)
        {
            this.userId = userId;
            this.realName = realName;
            this.message = message;
            this.avatarUrl = avatarUrl;

            setPostDateTime(timestamp);
        }

        // A method to format the post date/time
        private void setPostDateTime(DateTime timestamp)
        {
            formattedDate = timestamp.format('dd/MM/yy');
            formattedTime = timestamp.format('h:mm a');
            timestamp = timestamp;
        }
    }

    /* Slack Multiple message wrapper - May not need this, could just append the message from each slack message to the previous
    one on a new line?

    public class bg_SlackMultipleMessageWrapper
    {
    		// bg_SlackMessageWrapper public members
        public String userId;
        public String realName;
        public String firstName;
        public String lastName;
        public String message;
        public String formattedDate;
        public String formattedTime;
        public String avatarUrl;

        // bg_SlackMessageWrapper private members
        private DateTime timestamp;

        private Date postDate;

        private Time postTime;

        public bg_SlackMultipleMessageWrapper(String userId, String realName, List<String> messages, DateTime timestamp, String avatarUrl)
        {
            this.userId = userId;
            this.realName = realName;
            this.message = message;
            this.avatarUrl = avatarUrl;

            setPostDateTime(timestamp);
        }
    }*/
}