<?php
/*
 SPDX-License-Identifier: AGPL-3.0-only
 SPDX-FileCopyrightText: © 2024 Millions Missing FRANCE <info@millionsmissing.fr>
 */

namespace Modules\MMFRestrictedCustomers\Http\Controllers;

use Validator;

use Illuminate\Http\Request;

use App\Attachment;
use App\Conversation;
use App\Events\ConversationStatusChanged;
use App\Events\ConversationUserChanged;
use App\Events\UserAddedNote;
use App\Events\UserCreatedConversation;
use App\Events\UserReplied;
use App\Mailbox;
use App\MailboxUser;
use App\Thread;

use Modules\MMFRestrictedCustomers\Entities\Customer;

use App\Http\Controllers\ConversationsController as BaseConversationsController;

class ConversationsController extends BaseConversationsController {
	/**
	 * Conversations ajax controller.
	 */
	public function ajax(Request $request) {
		// This override is only required for "send_reply" requests.
		if ( $request->action != 'send_reply' )
			return parent::ajax($request);

		$response = [
			'status' => 'error',
			'msg'    => '', // this is error message
		];

		$user = auth()->user();

		$mailbox = Mailbox::findOrFail($request->mailbox_id);

		if (!$response['msg'] && !$user->can('view', $mailbox)) {
			$response['msg'] = __('Not enough permissions');
		}

		$conversation = null;
		if (!$response['msg'] && !empty($request->conversation_id)) {
			$conversation = Conversation::find($request->conversation_id);
			if ($conversation && !$user->can('view', $conversation)) {
				$response['msg'] = __('Not enough permissions');
			}
		}
		$new = false;
		if (empty($request->conversation_id)) {
			$new = true;
		}

		$is_note = false;
		if (!empty($request->is_note)) {
			$is_note = true;
		}

		// Conversation type.
		$type = Conversation::TYPE_EMAIL;
		if (!empty($request->type)) {
			$type = (int)$request->type;
		} elseif ($conversation) {
			$type = $conversation->type;
		}

		$is_phone = false;
		if ($type == Conversation::TYPE_PHONE) {
			$is_phone = true;
		}

		$is_custom = false;
		if ($type == Conversation::TYPE_CUSTOM) {
			$is_custom = true;
		}

		$is_create = false;
		if (!empty($request->is_create)) {
			//if ($new || ($from_draft && $conversation->threads_count == 1)) {
			$is_create = $request->is_create;
		}

		$is_forward = false;
		if (!empty($request->subtype) && (int)$request->subtype == Thread::SUBTYPE_FORWARD) {
			$is_forward = true;
		}

		$is_multiple = false;
		if (!empty($request->multiple_conversations)) {
			$is_multiple = true;
		}

		// If reply is being created from draft, there is already thread created
		$thread = null;
		$from_draft = false;
		if (( ! $is_note || $is_phone || $is_custom ) && ! $response['msg'] && ! empty($request->thread_id)) {
			$thread = Thread::find($request->thread_id);
			if ($thread && (!$conversation || $thread->conversation_id != $conversation->id)) {
				$response['msg'] = __('Incorrect thread');
			} else {
				$from_draft = true;
			}
		}

		if (!$response['msg']) {
			if ($thread && $from_draft && $thread->state == Thread::STATE_PUBLISHED) {
				$response['msg'] = __('Message has been already sent. Please discard this draft.');
			}
		}

		// Validate form
		if (!$response['msg']) {
			if ($new) {
				if ($type == Conversation::TYPE_EMAIL) {
					$validator = Validator::make($request->all(), [
						'to'       => 'required|array',
						'subject'  => 'required|string|max:998',
						'body'     => 'required|string',
						'cc'       => 'nullable|array',
						'bcc'      => 'nullable|array',
					]);
				} elseif ($type === Conversation::TYPE_PHONE) {
					// Phone conversation.
					$validator = Validator::make($request->all(), [
						'name'     => 'required|string',
						'subject'  => 'required|string|max:998',
						'body'     => 'required|string',
						'phone'    => 'nullable|string',
						'to_email' => 'nullable|string',
					]);
				} elseif ($type === Conversation::TYPE_CUSTOM) {
					$validation_rules = \Eventy::filter('conversation.custom.validation_rules', [
						'body' => 'required|string',
						'cc'   => 'nullable|array',
						'bcc'  => 'nullable|array',
					], $request);
					$validator        = Validator::make($request->all(), $validation_rules);
				}
			} else {
				$validator = Validator::make($request->all(), [
					'body'     => 'required|string',
					'cc'       => 'nullable|array',
					'bcc'      => 'nullable|array',
				]);
			}

			if ($validator->fails()) {
				foreach ($validator->errors()->getMessages()as $errors) {
					foreach ($errors as $field => $message) {
						$response['msg'] .= $message.' ';
					}
				}
			}
		}

		$body = $request->body;

		// Replace base64 images with attachment URLs in case text
		// was copy and pasted into the editor.
		// https://github.com/freescout-helpdesk/freescout/issues/3057
		$body = Thread::replaceBase64ImagesWithAttachments($body);

		// List of emails.
		$to_array = [];
		if ($is_forward) {
			$to_array = Conversation::sanitizeEmails($request->to_email);
		} else {
			$to_array = Conversation::sanitizeEmails($request->to);
		}
		// Check To
		if (! $response['msg'] && $new && ! $is_phone && ! $is_custom) {
			if (!$to_array) {
				$response['msg'] .= __('Incorrect recipients');
			}
		}

		// Check max. message size.
		if (!$response['msg']) {

			$max_message_size = (int)config('app.max_message_size');
			if ($max_message_size) {
				// Todo: take into account conversation history.
				$message_size = mb_strlen($body, '8bit');

				// Calculate attachments size.
				$attachments_ids = array_merge($request->attachments ?? [], $request->embeds ?? []);
				$attachments_ids = $this->decodeAttachmentsIds($attachments_ids);

				if (count($attachments_ids)) {
					$attachments_to_check = Attachment::select('size')->whereIn('id', $attachments_ids)->get();
					foreach ($attachments_to_check as $attachment) {
						$message_size += (int)$attachment->size;
					}
				}

				if ($message_size > $max_message_size*1024*1024) {
					$response['msg'] = __('Message is too large — :info. Please shorten your message or remove some attachments.', ['info' => __('Max. Message Size').': '.$max_message_size.' MB']);
				}
			}
		}

		if (!$response['msg']) {

			// Get attachments info
			// Delete removed attachments.
			$attachments_info = $this->processReplyAttachments($request);

			// Determine redirect.
			// Must be done before updating current conversation's status or assignee.
			// Redirect URL for new no saved yet conversation is determined below.
			if (!$new) {
				$response['redirect_url'] = $this->getRedirectUrl($request, $conversation, $user);
			}

			// Conversation
			$now = date('Y-m-d H:i:s');
			$status_changed = false;
			$user_changed = false;
			// Chat conversations in chat mode can not be undone.
			$can_undo = true;

			$request_status = (int)$request->status;

			if ($new) {
				// New conversation
				$conversation = new Conversation();
				$conversation->type = $type;
				$conversation->subject = $request->subject;
				$conversation->setPreview($body);
				$conversation->mailbox_id = $request->mailbox_id;
				$conversation->created_by_user_id = auth()->user()->id;
				$conversation->source_via = Conversation::PERSON_USER;
				$conversation->source_type = Conversation::SOURCE_TYPE_WEB;
			} else {
				// Reply or note
				if ($request_status && $request_status != (int)$conversation->status) {
					$status_changed = true;
				}
				if (!empty($request->subject)) {
					$conversation->subject = $request->subject;
				}
				// When switching from regular message to phone and message sent
				// without saving a draft type need to be saved here.
				// Or vise versa.
				if (($conversation->type == Conversation::TYPE_EMAIL && $type == Conversation::TYPE_PHONE)
					|| ($conversation->type == Conversation::TYPE_PHONE && $type == Conversation::TYPE_EMAIL)
				) {
					$conversation->type = $type;
				}
				// Allow to convert phone conversations into email conversations.
				if ($conversation->isPhone() && !$is_note && $conversation->customer
					&& $customer_email = $conversation->customer->getMainEmail()
				) {
					$conversation->type = Conversation::TYPE_EMAIL;
					$conversation->customer_email = $customer_email;
					$is_phone = false;
				}
			}

			if ($attachments_info['has_attachments']) {
				$conversation->has_attachments = true;
			}

			// Customer can be empty in existing conversation if this is a draft.
			$customer_email = '';
			$customer = null;

			if ($is_phone && $is_create) {
				// Phone.
				$phone_customer_data = $this->processPhoneCustomer($request);

				$customer_email = $phone_customer_data['customer_email'];
				$customer = $phone_customer_data['customer'];
				if (! $conversation->customer_id) {
					$conversation->customer_id = $customer->id;
				}
			} elseif ($is_custom) {
				// No customer for custom conversations.
			} else {
				// Email or reply to a phone conversation.
				if (!empty($to_array)) {
					$customer_email = $to_array[0];
				} elseif (!$conversation->customer_email
					&& ($conversation->isEmail() || $conversation->isPhone())
					&& $conversation->customer_id
					&& $conversation->customer
				) {
					// When replying to a phone conversation, we need to
					// set 'customer_email' for the conversation.
					$customer_email = $conversation->customer->getMainEmail();
				}
				if (!$conversation->customer_id) {
					// The new Customer must be linked to a specific Mailbox.
					$data = [];
					$data['mailbox_id'] = $conversation->mailbox_id;
					$customer = Customer::create($customer_email, $data);
					$conversation->customer_id = $customer->id;
				} else {
					$customer = $conversation->customer;
				}
			}
			if ($customer_email && !$is_note && !$is_forward) {
				$conversation->customer_email = $customer_email;
			}

			$prev_status = $conversation->status;

			$conversation->status = $request_status ?: $conversation->status;

			if (($prev_status != $conversation->status || $is_create)
				&& $conversation->status == Conversation::STATUS_CLOSED
			) {
				$conversation->closed_by_user_id = $user->id;
				$conversation->closed_at = date('Y-m-d H:i:s');
			}

			// We need to set state, as it may have been a draft.
			$prev_state = $conversation->state;
			$conversation->state = Conversation::STATE_PUBLISHED;

			// Set assignee
			$prev_user_id = $conversation->user_id;
			if ((int) $request->user_id != -1) {
				// Check if user has access to the current mailbox
				if ((int) $conversation->user_id != (int) $request->user_id && $mailbox->userHasAccess($request->user_id)) {
					$conversation->user_id = $request->user_id;
					$user_changed = true;
				}
			} else {
				$conversation->user_id = null;
			}

			// To is a single email string.
			$to = '';
			// List of emails.
			$to_list = [];
			if ($is_forward) {
				if (empty($request->to_email[0])) {
					$response['msg'] = __('Please specify a recipient.');
					return \Response::json($response);
				}
				$to = $request->to_email[0];
			} else {
				if (!empty($request->to)) {
					// When creating a new conversation, to is a list of emails.
					if (is_array($request->to)) {
						$to = $request->to[0];
					} else {
						$to = $request->to;
					}
				} else {
					$to = $conversation->customer_email;
				}
			}

			if (!$is_note && !$is_forward) {
				// Save extra recipients to CC
				if ($is_create && !$is_multiple && count($to_array) > 1) {
					$conversation->setCc(array_merge(Conversation::sanitizeEmails($request->cc), $to_array));
				} else {
					if (!$is_multiple) {
						$conversation->setCc(array_merge(Conversation::sanitizeEmails($request->cc), [$to]));
					} else {
						$conversation->setCc(Conversation::sanitizeEmails($request->cc));
					}
				}
				$conversation->setBcc($request->bcc);
				$conversation->last_reply_at = $now;
				$conversation->last_reply_from = Conversation::PERSON_USER;
				$conversation->user_updated_at = $now;
			}
			if ($conversation->isPhone() && $is_note) {
				$conversation->last_reply_at = $now;
				$conversation->last_reply_from = Conversation::PERSON_USER;
			}
			$conversation->updateFolder();
			if ($from_draft) {
				// Increment number of replies in conversation
				$conversation->threads_count++;
				// We need to set preview here as when conversation is created from draft,
				// ThreadObserver::created() method is not called.
				$conversation->setPreview($body);
			}
			$conversation->save();

			// Redirect URL for new not saved yet conversation must be determined here.
			if ($new) {
				$response['redirect_url'] = $this->getRedirectUrl($request, $conversation, $user);
			}

			// Fire events
			\Eventy::action('conversation.send_reply_save', $conversation, $request);

			if (!$new) {
				if ($status_changed) {
					event(new ConversationStatusChanged($conversation));
					\Eventy::action('conversation.status_changed', $conversation, $user, $changed_on_reply = true, $prev_status);
				}
				if ($user_changed) {
					event(new ConversationUserChanged($conversation, $user));
					\Eventy::action('conversation.user_changed', $conversation, $user, $prev_user_id);
				}
			}

			if ($conversation->state != $prev_state) {
				\Eventy::action('conversation.state_changed', $conversation, $user, $prev_state);
			}

			// Create thread
			if (!$thread) {
				$thread = new Thread();
				$thread->conversation_id = $conversation->id;
				if ($is_note || $is_forward) {
					$thread->type = Thread::TYPE_NOTE;
				} else {
					$thread->type = Thread::TYPE_MESSAGE;
				}
				$thread->source_via = Thread::PERSON_USER;
				$thread->source_type = Thread::SOURCE_TYPE_WEB;
			} else {
				if ($is_forward || $is_phone) {
					$thread->type = Thread::TYPE_NOTE;
				} else {
					$thread->type = Thread::TYPE_MESSAGE;
				}
				$thread->created_at = $now;
			}
			if ($new) {
				$thread->first = true;
			}
			$thread->user_id = $conversation->user_id;
			$thread->status = $request_status ?? $conversation->status;
			$thread->state = Thread::STATE_PUBLISHED;
			if (!$is_custom) {
				$thread->customer_id = $customer->id;
			}
			$thread->created_by_user_id = auth()->user()->id;
			$thread->edited_by_user_id = null;
			$thread->edited_at = null;
			$thread->body = $body;
			if ($is_create && !$is_multiple && count($to_array) > 1) {
				$thread->setTo($to_array);
			} else {
				$thread->setTo($to);
			}
			// We save CC and BCC as is and filter emails when sending replies
			$thread->setCc($request->cc);
			$thread->setBcc($request->bcc);
			if ($attachments_info['has_attachments'] && !$is_forward) {
				$thread->has_attachments = true;
			}
			if (!empty($request->saved_reply_id)) {
				$thread->saved_reply_id = $request->saved_reply_id;
			}

			$forwarded_conversations = [];
			$forwarded_threads = [];

			if ($is_forward) {
				// Create forwarded conversations.
				foreach ($to_array as $recipient_email) {
					$forwarded_conversation = $conversation->replicate();
					$forwarded_conversation->type = Conversation::TYPE_EMAIL;
					$forwarded_conversation->setPreview($thread->body);
					$forwarded_conversation->created_by_user_id = auth()->user()->id;
					$forwarded_conversation->source_via = Conversation::PERSON_USER;
					$forwarded_conversation->source_type = Conversation::SOURCE_TYPE_WEB;
					$forwarded_conversation->threads_count = 0; // Counter will be incremented in ThreadObserver.
					$forwarded_customer = Customer::create($recipient_email);
					$forwarded_conversation->customer_id = $forwarded_customer->id;
					// Reload customer object, otherwise it stores previous customer.
					$forwarded_conversation->load('customer');
					$forwarded_conversation->customer_email = $recipient_email;
					$forwarded_conversation->subject = 'Fwd: '.$forwarded_conversation->subject;
					//$forwarded_conversation->setCc(array_merge(Conversation::sanitizeEmails($request->cc), [$to]));
					$forwarded_conversation->setCc(Conversation::sanitizeEmails($request->cc));
					$forwarded_conversation->setBcc($request->bcc);
					$forwarded_conversation->last_reply_at = $now;
					$forwarded_conversation->last_reply_from = Conversation::PERSON_USER;
					$forwarded_conversation->user_updated_at = $now;
					if ($attachments_info['has_attachments']) {
						$forwarded_conversation->has_attachments = true;
					}
					$forwarded_conversation->updateFolder();
					$forwarded_conversation->save();

					$forwarded_thread = $thread->replicate();

					$forwarded_conversations[] = $forwarded_conversation;
					$forwarded_threads[] = $forwarded_thread;
				}

				// Set forwarding meta data.
				// todo: store array of numbers and IDs.
				$thread->subtype = Thread::SUBTYPE_FORWARD;
				$thread->setMeta(Thread::META_FORWARD_CHILD_CONVERSATION_NUMBER, $forwarded_conversation->number);
				$thread->setMeta(Thread::META_FORWARD_CHILD_CONVERSATION_ID, $forwarded_conversation->id);
			}

			// Conversation history.
			if (!empty($request->conv_history)) {
				if ($request->conv_history != 'global') {
					if ($is_forward && !empty($forwarded_threads)) {
						foreach ($forwarded_threads as $forwarded_thread) {
							$forwarded_thread->setMeta(Thread::META_CONVERSATION_HISTORY, $request->conv_history);
						}
					} else {
						$thread->setMeta(Thread::META_CONVERSATION_HISTORY, $request->conv_history);
					}
				}
			}

			// From (mailbox alias).
			if (!empty($request->from_alias)) {
				$thread->from = $request->from_alias;
			}

			\Eventy::action('thread.before_save_from_request', $thread, $request);
			$thread->save();

			// Save forwarded thread.
			if ($is_forward) {
				foreach ($forwarded_conversations as $i => $forwarded_conversation) {
					$forwarded_thread = $forwarded_threads[$i];

					$forwarded_thread->conversation_id = $forwarded_conversation->id;
					$forwarded_thread->type = Thread::TYPE_MESSAGE;
					$forwarded_thread->subtype = null;
					if ($attachments_info['has_attachments']) {
						$forwarded_thread->has_attachments = true;
					}
					$forwarded_thread->setMeta(Thread::META_FORWARD_PARENT_CONVERSATION_NUMBER, $conversation->number);
					$forwarded_thread->setMeta(Thread::META_FORWARD_PARENT_CONVERSATION_ID, $conversation->id);
					$forwarded_thread->setMeta(Thread::META_FORWARD_PARENT_THREAD_ID, $thread->id);
					\Eventy::action('send_reply.before_save_forwarded_thread', $forwarded_thread, $request);
					$forwarded_thread->save();
				}
			}

			// If thread has been created from draft, remove the draft
			// if ($request->thread_id) {
			//     $draft_thread = Thread::find($request->thread_id);
			//     if ($draft_thread) {
			//         $draft_thread->delete();
			//     }
			// }

			if ($from_draft) {
				// Remove conversation from drafts folder if needed
				$conversation->maybeRemoveFromDrafts();
			}

			// Update folders counters
			$conversation->mailbox->updateFoldersCounters();

			$response['status'] = 'success';

			// Set thread_id for uploaded attachments
			if ($attachments_info['attachments']) {
				if ($is_forward) {
					// Copy attachments for each thread.
					if (count($forwarded_threads) > 1) {
						$attachments = Attachment::whereIn('id', $attachments_info['attachments'])->get();
					}
					foreach ($forwarded_threads as $i => $forwarded_thread) {
						if ($i == 0) {
							Attachment::whereIn('id', $attachments_info['attachments'])->update(['thread_id' => $forwarded_thread->id]);
						} else {
							foreach ($attachments as $attachment) {
								$attachment->duplicate($forwarded_thread->id);
							}
						}
					}
				} else {
					Attachment::whereIn('id', $attachments_info['attachments'])
						->where('thread_id', null)
						->update(['thread_id' => $thread->id]);
				}
			}

			// Follow conversation if it's assigned to someone else.
			if (!$is_create && !$new && !$is_forward && !$is_note
				&& $conversation->user_id != $user->id
			) {
				$user->followConversation($conversation->id);
			}

			if ($conversation->isChat() && \Helper::isChatMode()) {
				$can_undo = false;
			}

			// When user creates a new conversation it may be saved as draft first.
			if ($is_create) {
				// New conversation.
				event(new UserCreatedConversation($conversation, $thread));
				\Eventy::action('conversation.created_by_user_can_undo', $conversation, $thread);
				// After Conversation::UNDO_TIMOUT period trigger final event.
				\Helper::backgroundAction('conversation.created_by_user', [$conversation, $thread], now()->addSeconds($this->getUndoTimeout($can_undo)));
			} elseif ($is_forward) {
				// Forward.
				// Notifications to users not sent.
				event(new UserAddedNote($conversation, $thread));
				foreach ($forwarded_conversations as $i => $forwarded_conversation) {
					$forwarded_thread = $forwarded_threads[$i];

					// To send email with forwarded conversation.
					event(new UserReplied($forwarded_conversation, $forwarded_thread));
					\Eventy::action('conversation.user_forwarded_can_undo', $conversation, $thread, $forwarded_conversation, $forwarded_thread);
					// After Conversation::UNDO_TIMOUT period trigger final event.
					\Helper::backgroundAction('conversation.user_forwarded', [$conversation, $thread, $forwarded_conversation, $forwarded_thread], now()->addSeconds(Conversation::UNDO_TIMOUT));
				}
			} elseif ($is_note) {
				// Note.
				event(new UserAddedNote($conversation, $thread));
				\Eventy::action('conversation.note_added', $conversation, $thread);
			} else {
				// Reply.
				event(new UserReplied($conversation, $thread));
				\Eventy::action('conversation.user_replied_can_undo', $conversation, $thread);
				// After Conversation::UNDO_TIMOUT period trigger final event.
				\Helper::backgroundAction('conversation.user_replied', [$conversation, $thread], now()->addSeconds($this->getUndoTimeout($can_undo)));
			}

			// Send new conversation separately to each customer.
			if ($is_create && count($to_array) > 1 && $is_multiple) {
				$prev_customers_ids = [];
				foreach ($to_array as $i => $customer_email) {
					// Skip first email, as conversation has already been created for it.
					if ($i == 0) {
						continue;
					}
					// Get customer by email.
					$customer_tmp = Customer::getByEmail($customer_email);
					// Skip same customers.
					if ($customer_tmp && in_array($customer_tmp->id, $prev_customers_ids)) {
						continue;
					}

					if (!$customer_tmp) {
						$customer_tmp = Customer::create($customer_email);
					}

					$prev_customers_ids[]  = $customer_tmp->id;

					// Copy conversation and thread.
					$conversation_copy = $conversation->replicate();
					$thread_copy = $thread->replicate();

					// Save conversation.
					$conversation_copy->threads_count = 0;
					$conversation_copy->customer_id = $customer_tmp->id;
					// Reload customer, otherwise all recipients will have the same name.
					$conversation_copy->load('customer');
					$conversation_copy->customer_email = $customer_email;
					$conversation_copy->has_attachments = $conversation->has_attachments;
					$conversation_copy->push();

					$thread_copy->conversation_id = $conversation_copy->id;
					$thread_copy->customer_id = $customer_tmp->id;
					$thread_copy->has_attachments = $conversation->has_attachments;
					$thread_copy->setTo($customer_email);
					// Reload the conversation, otherwise Thread observer will be 
					// increasing threads_count for the first conversation.
					$thread_copy->load('conversation');
					$thread_copy->push();

					// Copy attachments.
					if (!empty($attachments_info['attachments'])) {
						$attachments = Attachment::whereIn('id', $attachments_info['attachments'])->get();
						foreach ($attachments as $attachment) {
							$attachment->duplicate($thread_copy->id);
						}
					}

					// Events.
					// todo: allow to undo all emails
					event(new UserCreatedConversation($conversation_copy, $thread_copy));
					\Eventy::action('conversation.created_by_user_can_undo', $conversation_copy, $thread_copy);
					// After Conversation::UNDO_TIMOUT period trigger final event.
					\Helper::backgroundAction('conversation.created_by_user', [$conversation_copy, $thread_copy], now()->addSeconds($this->getUndoTimeout($can_undo)));
				}
			}

			// Compose flash message.
			$show_view_link = true;
			if (!empty($request->after_send) && $request->after_send == MailboxUser::AFTER_SEND_STAY) {
				$show_view_link = false;
			}

			$flash_vars = ['%tag_start%' => '<strong>', '%tag_end%' => '</strong>', '%view_start%' => '&nbsp;<a href="'.$conversation->url().'">', '%a_end%' => '</a>&nbsp;', '%undo_start%' => '&nbsp;<a href="'.route('conversations.undo', ['thread_id' => $thread->id]).'" class="text-danger">'];

			if ($is_phone) {
				$flash_type = 'warning';
				if ($show_view_link) {
					$flash_text = __(':%tag_start%Conversation created:%tag_end% :%view_start%View:%a_end% or :%undo_start%Undo:%a_end%', $flash_vars);
				} else {
					$flash_text = '<strong>'.__('Conversation created').'</strong>';
				}
			} elseif ($is_custom) {
				$flash_type = 'warning';
				$identifier = \Eventy::filter('conversation.custom.identifier', __('Custom conversation'), $request);
				if ($show_view_link) {
					$flash_text = __(':%tag_start%' . $identifier . ' added:%tag_end% :%view_start%View:%a_end%', $flash_vars);
				} else {
					$flash_text = '<strong>'.__('%identifier% added',['%identifier%'=>$identifier]).'</strong>';
				}
			} elseif ($is_note) {
				$flash_type = 'warning';
				if ($show_view_link) {
					$flash_text = __(':%tag_start%Note added:%tag_end% :%view_start%View:%a_end%', $flash_vars);
				} else {
					$flash_text = '<strong>'.__('Note added').'</strong>';
				}
			} else {
				$flash_type = 'success';
				if ($show_view_link) {
					$flash_text = __(':%tag_start%Email Sent:%tag_end% :%view_start%View:%a_end% or :%undo_start%Undo:%a_end%', $flash_vars);
				} else {
					$flash_text = __(':%tag_start%Email Sent:%tag_end% :%undo_start%Undo:%a_end%', $flash_vars);
				}
			}

			if ($can_undo) {
				\Session::flash('flash_'.$flash_type.'_floating', $flash_text);
			}
		}

		if ($response['status'] == 'error' && empty($response['msg'])) {
			$response['msg'] = 'Unknown error occurred';
		}

		return \Response::json($response);
	}
}