<?php

namespace FluentSupport\App\Services;

use Exception;
use FluentSupport\App\Http\Policies\PortalPolicy;
use FluentSupport\App\Models\MailBox;
use FluentSupport\App\Models\Meta;
use FluentSupport\App\Models\Ticket;
use FluentSupport\App\Models\Customer;
use FluentSupport\App\Services\Tickets\AgentTicketAccess;
use FluentSupport\App\Services\Tickets\ResponseService;
use FluentSupport\App\Services\Tickets\TicketService;
use FluentSupport\Framework\Support\Arr;
use FluentSupport\App\Models\Attachment;
use FluentSupport\App\Models\Conversation;

class CustomerPortalService
{
    /**
     * Ticket columns a customer never sees: the agent-set priority and the
     * email threading / dedupe internals.
     */
    const PRIVATE_TICKET_FIELDS = ['priority', 'message_id', 'content_hash', 'secret_content'];

    /**
     * Hide PRIVATE_TICKET_FIELDS on a ticket, or on each ticket of a list or page.
     *
     * @param mixed $tickets
     * @return mixed
     */
    public static function hidePrivateTicketFields($tickets)
    {
        if ($tickets instanceof Ticket) {
            $tickets->makeHidden(self::PRIVATE_TICKET_FIELDS);
        } elseif (is_iterable($tickets)) {
            foreach ($tickets as $ticket) {
                if ($ticket instanceof Ticket) {
                    $ticket->makeHidden(self::PRIVATE_TICKET_FIELDS);
                }
            }
        }

        return $tickets;
    }

    /**
     * @param object $customer
     * @param string $requestedStatus
     * @param array|null $options
     * @return object
     * @throws Exception
     * @since 1.8.1
     */
    public function getTickets($customer, $requestedStatus, $options = [])
    {
        $this->validateCustomer($customer);

        $statuses = $this->getTicketStatues($requestedStatus);

        return $this->ticketsAdditionalData($customer, $statuses, $options);
    }

    /**
     * @param array $customerAdditionalData
     * @param int $ticketId
     * @return array
     * @since 1.5.7
     */
    public function getTicket($customerAdditionalData, $ticketId)
    {
        $ticket = $this->getTicketByID($ticketId);

        // Same message as a denied ticket, so an unknown number reveals nothing.
        if (!$ticket) {
            throw new \Exception(esc_html__('Sorry, You do not have permission to this support ticket', 'fluent-support'));
        }

        // translators: %s is the time duration (e.g., "2 hours", "3 days")
        $ticket->human_date = sprintf(__('%s ago', 'fluent-support'), human_time_diff(strtotime($ticket->created_at), current_time('timestamp')));

        $customer = $this->getCustomer($customerAdditionalData, $ticket);

        $this->checkCustomerTicketAccess($customer, $ticket);

        return [
            'ticket'     => $this->syncTicketAdditionData($ticket),
            'responses'  => $this->getResponses($ticket->id),
            'sign_on_id' => $ticket->customer_id
        ];
    }

    /**
     * @param object $customer
     * @param array $data
     * @param int $mailboxId
     * @param bool $onBehalf Filed by a remote portal for the customer; their uploads are the customer's.
     * @return Ticket
     * @throws Exception
     */
    public function createTicket($customer, $data, $mailboxId, $onBehalf = false)
    {
        $this->validateCustomer($customer);

        $data = $this->onlyAllowedPortalTicketFields($data);

        // Already unslashed at the request boundary. Don't unslash again or literal backslashes are lost.
        $data['title'] = sanitize_text_field($data['title']);
        $data['content'] = wp_kses_post($data['content']);
        $data['customer_id'] = $customer->id;
        $data['product_source'] = 'local';
        $data['mailbox_id'] = $this->resolveMailboxId($mailboxId);
        $data['source'] = 'web';

        $disabledFields = apply_filters('fluent_support/disabled_ticket_fields', []);
        $this->validateDisabledFields($data, $disabledFields);

        return $this->storeTicket($data, $customer, $disabledFields, $onBehalf);
    }

    /**
     * The validator returns the whole payload, and many fillable Ticket columns (agent_id,
     * status, privacy, ...) are agent-only, so keep only what a customer may set.
     *
     * @param array $data
     * @return array
     */
    private function onlyAllowedPortalTicketFields($data)
    {
        $allowedKeys = [
            'title',
            'content',
            'product_id',
            'client_priority',
            'custom_data',
            'attachments',
            'message_id',
        ];

        return array_intersect_key($data, array_flip($allowedKeys));
    }


    /**
     * @param array $customerAdditionalData
     * @param int $ticketId
     * @param array $data
     * @return array
     * @throws Exception
     * @since 1.5.7
     */
    public function createResponse($customerAdditionalData, $ticketId, $data)
    {
        // Already unslashed at the request boundary; ResponseService sanitizes it.
        $data['conversation_type'] = 'response';

        $ticket = Ticket::with(['customer'])->wherePublicIdentifier($ticketId)->firstOrFail();
        $customer = $this->getCustomer($customerAdditionalData, $ticket);

        $this->checkCustomerTicketAccess($customer, $ticket, 'response');

        // Checked before anything changes, so a blank reply neither reopens nor saves.
        if (!$this->hasReplyContent(Arr::get($data, 'content'))) {
            throw new \Exception(esc_html__('Please write a reply before sending.', 'fluent-support'));
        }

        // A reply reopens a closed ticket, as an emailed reply does, so it is never left
        // closed with an unanswered customer message in it. Reopened before the reply is
        // saved, as email piping does, so the reply hooks see an active ticket. Not when
        // the customer asked to close it with this reply.
        if ($ticket->status == 'closed' && Arr::get($data, 'close_ticket') != 'yes') {
            (new TicketService())->reopen($ticket, $customer);
        }

        $responseData = (new ResponseService())->createResponse($data, $customer, $ticket);

        if (!$responseData) {
            throw new \Exception(esc_html__('Please write a reply before sending.', 'fluent-support'));
        }

        $responseData['ticket'] = Ticket::find($ticket->id);
        $responseData['response']->content = Helper::refreshSignedAttachmentUrls($responseData['response']->content, $ticket->id);
        $responseData['response']->load([
            'attachments' => function ($query) {
                $query->where('status', 'active');
            }
        ]);

        return [
            'message'  => __('Reply has been added', 'fluent-support'),
            'response' => $responseData['response'],
            'ticket'   => self::hidePrivateTicketFields($responseData['ticket'])
        ];
    }


    /**
     * @param array $customerAdditionalData
     * @param int $ticketId
     * @return array
     * @throws Exception
     */
    public function closeTicket($customerAdditionalData, $ticketId)
    {
        $ticket = Ticket::with(['customer'])->wherePublicIdentifier($ticketId)->firstOrFail();
        $customer = $this->getCustomer($customerAdditionalData, $ticket);

        $this->checkCustomerTicketAccess($customer, $ticket, 'close');

        return [
            'message' => __('Ticket has been closed', 'fluent-support'),
            'ticket'  => self::hidePrivateTicketFields((new TicketService())->close($ticket, $customer))
        ];
    }

    /**
     * @param array $customerAdditionalData
     * @param int $ticketId
     * @return array
     * @throws Exception
     */
    public function reOpenTicket($customerAdditionalData, $ticketId)
    {
        $ticket = Ticket::with(['customer'])->wherePublicIdentifier($ticketId)->firstOrFail();
        $customer = $this->getCustomer($customerAdditionalData, $ticket);

        $this->checkCustomerTicketAccess($customer, $ticket, 'reopen');

        return [
            'message' => __('Ticket has been opened again', 'fluent-support'),
            'ticket'  => self::hidePrivateTicketFields((new TicketService())->reopen($ticket, $customer))
        ];
    }

    /**
     * @param array $data
     * @param array $disabledFields
     * @return array $data
     * @since 1.5.7
     */
    private function validateDisabledFields($data, $disabledFields)
    {
        if (!in_array('priority', $disabledFields)) {
            $data['priority'] = sanitize_text_field($data['client_priority'] ?? '');
            $data['client_priority'] = sanitize_text_field($data['client_priority'] ?? '');
        }

        if (in_array('product_services', $disabledFields)) {
            unset($data['product_id']);
        }

        return $data;
    }


    /**
     * @param array $data
     * @param object $customer
     * @param array $disabledFields
     * @param bool $onBehalf
     * @return Ticket
     * @since 1.5.7
     */
    private function storeTicket($data, $customer, $disabledFields, $onBehalf = false)
    {
        /*
         * Filter ticket data before it's saved.
         *
         * @since v1.0.0
         * @param array  $data
         * @param object $customer
         */
        $data = apply_filters('fluent_support/create_ticket_data', $data, $customer);

        /*
         * Fires before the ticket is created.
         *
         * @since v1.0.0
         * @param array  $data
         * @param object $customer
         */
        do_action('fluent_support/before_ticket_create', $data, $customer);

        $ticket = Ticket::create($data);

        TicketService::addTicketAttachments($data, $disabledFields, $ticket, $customer, $onBehalf);
        $this->addCustomData($data, $ticket);

        do_action('fluent_support/ticket_created', $ticket, $customer);

        return $ticket;
    }


    /**
     * @param array $data
     * @param object $ticket
     * @return void
     */
    private function addCustomData($data, $ticket)
    {
        if (defined('FLUENTSUPPORTPRO')) {
            $customData = Arr::get($data, 'custom_data');
            if ($customData) {
                $ticket->syncCustomFields($customData);
            }
        }
    }

    /**
     * @param object|null $customer
     * @since 1.5.7
     * @throws Exception
     */
    private function validateCustomer($customer)
    {
        if (!$customer) {
            throw new \Exception(esc_html__('Customer not found', 'fluent-support'));
        }

        if (!$customer->canAccessPortal()) {
            throw new \Exception(esc_html__('Sorry, You do not have access to customer portal', 'fluent-support'));
        }
    }

    /**
     * With a valid signed ticket hash the ticket's own customer is used, otherwise the current user.
     *
     * @param array $customerAdditionalData
     * @param object $ticket
     * @return object $customer
     * @throws Exception
     *
     * @since 1.5.7
     */
    public function getCustomer($customerAdditionalData, $ticket)
    {
        $intendedHash = Arr::get($customerAdditionalData, 'intended_ticket_hash');
        if ($intendedHash && Helper::isPublicSignedTicketEnabled()) {
            if (!is_string($intendedHash) || !hash_equals((string) $ticket->hash, $intendedHash)) {
                throw new \Exception(esc_html__('Sorry, You do not have permission to this support ticket', 'fluent-support'));
            }
            $customer = $ticket->customer;
        } else {
            $onBehalf = Arr::get($customerAdditionalData, 'on_behalf');

            // Signed links are off: see PortalPolicy::maybePublicSignedRequest().
            if ($intendedHash && !$onBehalf && PortalPolicy::canActOnBehalf()) {
                throw new \Exception(esc_html__('Sorry, You do not have permission to this support ticket', 'fluent-support'));
            }

            // An agent acting for a customer keeps their own mailbox and visibility limits.
            // Site admins have full access and may not have an agent record at all.
            if ($onBehalf && !current_user_can('manage_options') && !(new AgentTicketAccess())->currentAgentCanAccess($ticket)) {
                throw new \Exception(esc_html__('Sorry, You do not have permission to this support ticket', 'fluent-support'));
            }

            $customer = $this->resolveCustomer($onBehalf, Arr::get($customerAdditionalData, 'user_ip'));
        }

        if (!$customer) {
            throw new \Exception(esc_html__('Sorry! No customer found', 'fluent-support'));
        }

        return $customer;
    }

    /**
     * @param string $requestedStatus
     * @return array
     * @since 1.8.1
     */
    private function getTicketStatues($requestedStatus)
    {
        $statuses = [
            'open'   => ['new', 'active', 'on-hold'],
            'all'    => [],
            'closed' => ['closed']
        ];

        return Arr::get($statuses, $requestedStatus, []);
    }


    /**
     * @param object $customer
     * @param array $statuses
     * @param array|null $options
     * @return object $tickets
     * @since 1.5.7
     */
    private function ticketsAdditionalData($customer, $statuses, $options = [])
    {
        $defaultOptions = [
            'search'  => null,
            'sorting' => null,
            'filters' => null
        ];

        $ticketOptions = wp_parse_args($options, $defaultOptions);

        $tickets = Ticket::with([
            'customer' => function ($query) {
                $query->select(['first_name', 'last_name', 'id']);
            }, 'agent' => function ($query) {
                $query->select(['first_name', 'last_name', 'id']);
            }
        ])->where('customer_id', $customer->id)
            ->when(!empty($ticketOptions['sorting'] && !empty($ticketOptions['sorting']['sort_by'])), function ($query) use ($ticketOptions) {
                return $query->orderBy(sanitize_sql_orderby($ticketOptions['sorting']['sort_by']), sanitize_sql_orderby($ticketOptions['sorting']['sort_type']));
            })
            ->when(!empty($options['filters']['product_id']), function ($query) use ($ticketOptions) {
                return $query->where('product_id', $ticketOptions['filters']['product_id']);
            })
            ->when($statuses, function ($query) use ($statuses) {
                return $query->whereIn('status', $statuses);
            })
            ->when($ticketOptions['search'], function ($query) use ($ticketOptions) {
                return $query->searchBy($ticketOptions['search']);
            })
            ->when(empty($ticketOptions['sorting']), function ($query) {
                return $query->latest('updated_at');
            })
            ->paginate();

        foreach ($tickets as $ticket) {
            // translators: %s is the time duration (e.g., "2 hours", "3 days")
            $ticket->human_date = sprintf(__('%s ago', 'fluent-support'), human_time_diff(strtotime($ticket->created_at), current_time('timestamp')));
            $ticket->preview_response = $ticket->getLastResponse();
        }

        return self::hidePrivateTicketFields($tickets);
    }

    /**
     * Keeps only scalar values, so sanitize_text_field() never gets an array.
     * An empty result makes resolveCustomer() use the logged-in user.
     *
     * @param mixed $onBehalf
     * @return array
     */
    public function sanitizeOnBehalf($onBehalf)
    {
        if (!is_array($onBehalf)) {
            return [];
        }

        $sanitized = [];

        foreach ($onBehalf as $key => $value) {
            if (is_scalar($value)) {
                $sanitized[sanitize_text_field($key)] = sanitize_text_field($value);
            }
        }

        return $sanitized;
    }

    /**
     * Find the customer for $onBehalf (or the current user), creating it when $forceCreate is set.
     *
     * @param array $onBehalf
     * @param string $userIp
     * @param bool $forceCreate
     * @return Customer|false
     */
    public function resolveCustomer($onBehalf, $userIp, $forceCreate = false)
    {
        if (!$onBehalf) {
            $user = get_user_by('ID', get_current_user_id());
            if (!$user) {
                return false;
            }

            $onBehalf = [
                'user_id'         => $user->ID,
                'email'           => $user->user_email,
                'last_ip_address' => $userIp
            ];
        }

        if ($forceCreate) {
            return Customer::maybeCreateCustomer($onBehalf);
        }

        return Customer::getCustomerFromData($onBehalf);
    }

    /**
     * Whether a reply has something to read: text, or an image. Editors leave markup
     * such as <p>&nbsp;</p> behind when the text is deleted.
     *
     * @param mixed $content
     * @return bool
     */
    private function hasReplyContent($content)
    {
        // ResponseService refuses whatever empty() treats as empty, "0" included.
        if (!is_string($content) || empty($content)) {
            return false;
        }

        if (stripos($content, '<img') !== false) {
            return true;
        }

        $text = wp_strip_all_tags(str_ireplace(['&nbsp;', '&#160;'], ' ', $content));

        return trim(html_entity_decode($text, ENT_QUOTES, 'UTF-8'), " \t\n\r\0\x0B\xC2\xA0") !== '';
    }

    /**
     * The given mailbox's id, falling back to the default mailbox.
     *
     * @param int $mailboxId
     * @return int|null
     */
    public function resolveMailboxId($mailboxId)
    {
        $mailbox = MailBox::find($mailboxId);
        if ($mailbox) {
            return $mailbox->id;
        }

        $mailbox = Helper::getDefaultMailBox();

        if ($mailbox) {
            return $mailbox->id;
        }
        return null;
    }

    /**
     * @param int|string $ticketId
     * @return object $ticket
     */
    private function getTicketByID($ticketId)
    {
        $ticket = Ticket::wherePublicIdentifier($ticketId)
            ->with([
                'customer'    => function ($query) {
                    $query->select(['first_name', 'email', 'person_type', 'last_name', 'id', 'avatar']);
                }, 'agent'    => function ($query) {
                    $query->select(['first_name', 'email', 'person_type', 'last_name', 'id', 'title', 'avatar']);
                },
                'product',
                'attachments' => function ($q) {
                    $q->where('status', 'active');
                }
            ])
            ->first();

        return $ticket;
    }

    /**
     * @param object $customer
     * @param object $ticket
     * @param string|false $action
     * @return bool true if access is granted
     * @throws Exception
     */
    public function checkCustomerTicketAccess($customer, $ticket, $action = false)
    {
        if (!$customer) {
            throw new \Exception(esc_html__('Sorry, You do not have permission to this support ticket', 'fluent-support'));
        }

        if (!$customer->canAccessPortal()) {
            throw new \Exception(esc_html__('Sorry, You do not have access to customer portal', 'fluent-support'));
        }

        if ($ticket->privacy == 'private' && $customer->id != $ticket->customer_id) {
            if ($action) {
                throw new \Exception(sprintf(
                    // translators: %s is the action being performed (e.g., "view", "edit", "delete")
                    esc_html__("Sorry! You cannot %s this ticket", 'fluent-support'),
                    esc_html($action)
                ));
            } else {
                throw new \Exception(esc_html__('You do not have permission to view this support ticket', 'fluent-support'));
            }
        }

        $result = apply_filters('fluent_support/can_customer_access_ticket', true, $customer, $ticket, $action);

        if ($result && !is_wp_error($result)) {
            return $result;
        }

        if (!$result) {
            throw new \Exception(esc_html__('Sorry, You cannot access this ticket', 'fluent-support'));
        }

        throw new \Exception(esc_html($result->get_error_message()));
    }


    /**
     * @param int $ticketId
     * @return mixed
     */
    private function getResponses($ticketId)
    {
        $responses = Conversation::where('ticket_id', $ticketId)
            ->with([
                'person' => function ($query) {
                    $query->select(['first_name', 'email', 'person_type', 'last_name', 'id', 'title', 'avatar']);
                },
                'attachments' => function ($query) {
                    $query->where('status', 'active');
                }
            ])
            ->filterByType(['response', 'ticket_merge_activity', 'ticket_split_activity'])
            ->orderBy('created_at', 'desc')
            ->orderBy('id', 'desc')
            ->get();

        $contents = [];
        foreach ($responses as $response) {
            $contents[$response->id] = $response->content;
        }

        $contents = Helper::refreshSignedAttachmentUrlsInContents($contents, $ticketId);

        $feedbacks = [];
        if (defined('FLUENTSUPPORTPRO_PLUGIN_VERSION') && Helper::isAgentFeedbackEnabled()) {
            $responseIds = $responses->pluck('id')->toArray();
            if ($responseIds) {
                $feedbacks = Meta::where('object_type', 'conversation_meta')
                    ->where('key', 'agent_feedback_ratings')
                    ->whereIn('object_id', $responseIds)
                    ->get()
                    ->keyBy('object_id');
            }
        }

        foreach ($responses as $response) {
            if ($feedbacks && $feedbacks->has($response->id)) {
                $response->agent_feedback = $feedbacks->get($response->id)->value;
            }

            // translators: %s is the time duration (e.g., "2 hours", "3 days")
            $response->human_date = sprintf(__('%s ago', 'fluent-support'), human_time_diff(strtotime($response->created_at), current_time('timestamp')));
            if (isset($contents[$response->id])) {
                $response->content = $contents[$response->id];
            }

            $responseContent = apply_filters('fluent_support/response_content_before_render', $response->content, $response, null);
            $responseContent = links_add_target(make_clickable($responseContent));
            $response->content = apply_filters('fluent_support/response_content_after_render', $responseContent, $response, null);

            if ($response->person) {
                $response->person->setHidden(['email']);
            }
        }

        return $responses;
    }

    /**
     * @param object $ticket
     * @return object $ticket
     */
    private function syncTicketAdditionData($ticket)
    {
        $ticket->content = Helper::refreshSignedAttachmentUrls($ticket->content, $ticket->id);
        $ticketContent = apply_filters('fluent_support/ticket_content_before_render', $ticket->content, $ticket);
        $ticketContent = links_add_target(make_clickable($ticketContent));
        $ticket->content = apply_filters('fluent_support/ticket_content_after_render', $ticketContent, $ticket);

        if ($ticket->customer) {
            $ticket->customer->setHidden(['email']);
        }

        if ($ticket->agent) {
            $ticket->agent->setHidden(['email']);
        }

        if ($ticket->status == 'closed') {
            $ticket->load('closed_by_person');
            if ($ticket->closed_by_person) {
                $ticket->closed_by_person->setVisible(['first_name', 'last_name', 'id', 'full_name', 'photo']);
            }
        }

        if (defined('FLUENTSUPPORTPRO')) {
            $ticket->custom_fields = $ticket->customData('public', true);
        }

        // Set when an agent opened the ticket on the customer's behalf. Only the
        // display fields leave the server: the loaded Agent row carries the
        // agent's email, IP and user id, so it is dropped again after reading.
        if ($ticket->created_by) {
            $ticket->load('created_by_person');
            if ($ticket->created_by_person) {
                $ticket->created_by_agent = [
                    'full_name'       => $ticket->created_by_person->full_name,
                    'photo'           => $ticket->created_by_person->photo,
                    // The agent's first response is the opening message; skip the placeholder body.
                    'agent_initiated' => $ticket->isAgentInitiated(),
                ];
            }
            $ticket->unsetRelation('created_by_person');
        }

        return self::hidePrivateTicketFields($ticket);
    }

    /**
     * @param string $approvalStatus
     * @param int    $conversationID
     * @param int    $ticketId The authorized ticket ID the conversation must belong to
     * @throws Exception
     */
    public function addUserFeedback($approvalStatus, $conversationID, $ticketId)
    {
        if (!in_array($approvalStatus, ['like', 'dislike'], true)) {
            throw new Exception(esc_html__('Invalid feedback value provided', 'fluent-support'));
        }

        $conversation = Conversation::with('person')
            ->where('id', $conversationID)
            ->where('ticket_id', $ticketId)
            ->where('conversation_type', 'response')
            ->first();

        if (!$conversation || !$conversation->person || $conversation->person->person_type !== 'agent') {
            throw new Exception(esc_html__('Invalid conversation for feedback', 'fluent-support'));
        }

        $existingAgentFeedback = Meta::where([
            'object_id'   => $conversationID,
            'object_type' => 'conversation_meta',
            'key'         => 'agent_feedback_ratings',
        ])->first();

        if ($existingAgentFeedback) {
            $wasRemoved = $existingAgentFeedback->value === $approvalStatus;
            $result = $this->updateExistingFeedback($existingAgentFeedback, $approvalStatus);
            if (!$wasRemoved) {
                $this->fireFeedbackReceived($approvalStatus, $conversation);
            }
            return $result;
        }

        $agentFeedback = Meta::create([
            'object_id' => $conversationID,
            'key' => 'agent_feedback_ratings',
            'object_type' => 'conversation_meta',
            'value' => $approvalStatus,
        ]);

        $this->fireFeedbackReceived($approvalStatus, $conversation);

        return $agentFeedback;
    }

    /**
     * A customer rated an agent's reply (or changed the rating). Clicking the
     * same rating again removes it and fires nothing. Each rating fires at most
     * once per reply, so clicking back and forth can't rerun workflows.
     *
     * @param string $rating 'like' or 'dislike'
     * @param Conversation $conversation The rated reply.
     * @return void
     */
    private function fireFeedbackReceived($rating, $conversation)
    {
        $ticket = Ticket::with('customer')->find($conversation->ticket_id);

        if (!$ticket) {
            return;
        }

        $firedKey = '_agent_feedback_fired_' . $rating;
        $alreadyFired = Meta::where('object_type', 'conversation_meta')
            ->where('object_id', $conversation->id)
            ->where('key', $firedKey)
            ->exists();

        if ($alreadyFired) {
            return;
        }

        Meta::create([
            'object_type' => 'conversation_meta',
            'object_id'   => $conversation->id,
            'key'         => $firedKey,
            'value'       => current_time('mysql'),
        ]);

        /*
         * Fires when a customer likes or dislikes an agent's reply.
         *
         * @since 2.4.1
         * @param string       $rating       'like' or 'dislike'
         * @param Conversation $conversation The rated reply.
         * @param Ticket       $ticket
         * @param Customer     $customer
         */
        do_action('fluent_support/agent_feedback_received', $rating, $conversation, $ticket, $ticket->customer);
    }

    private function updateExistingFeedback($existingAgentFeedback, $approvalStatus)
    {
        if (($existingAgentFeedback->value === 'like' && $approvalStatus === 'like') ||
            ($existingAgentFeedback->value === 'dislike' && $approvalStatus === 'dislike')) {
             $existingAgentFeedback->delete();
        } else {
              $existingAgentFeedback->update([
                'value' => $approvalStatus,
            ]);
        }
        return $existingAgentFeedback;
    }

}