<?php

defined('BASEPATH') or exit('No direct script access allowed');


class User_messaging extends MY_Controller

{


    public function __construct()

    {

        parent::__construct();


        $no_logged_methods = array();


        if (empty($this->session->logged) && !in_array($this->router->fetch_method(), $no_logged_methods)) {

            $this->session->set_flashdata('show_login_form', true);

            redirect('engine/error?http_code=403');

        }


        $this->load->model(array('users_inbox_model' => 'inbox_model'));

    }


    public function index()

    {

        //$this->output->enable_profiler();


        $action = $this->input->get('action');

        switch ($action) {

            case 'read':

                $this->read_private_message();

                break;

            case 'write':

                $this->send_message();

                break;

            case 'limits':

                $this->get_limits();

                break;

            default:

                $this->get_inbox_home();

        }

    }


    private function get_inbox_home()

    {

        $pagination_config = $this->_get_pagination_config();


        $offset = $this->input->get('page', true);


        if (empty($offset))

        {

            $offset = 0;

        }


        $pagination_config['per_page']   = 25;

        $pagination_config['total_rows'] = $this->inbox_model->get_pm_count($this->session->id);


        $this->pagination->initialize($pagination_config);


        $auto_messages       = $this->inbox_model->get_auto_messages();


        // Get all inbox messages

        $classicMessages = $this->inbox_model->get_inbox_messages($pagination_config['per_page'], $offset);


        $session_status = $this->session->status_auto_messages;

        $session_status = json_decode($session_status, JSON_OBJECT_AS_ARRAY);


        foreach ($auto_messages as $k => $auto_message) 

        {

            $auto_message->string_type = 'auto_message';

            $key = 'message_'.$auto_message->id;


            if($session_status[$key] == 'deleted')

            {

                unset($auto_messages[$k]);

            }


            if($auto_message->type == 1)

            {

                $ascent = Ygg::get_ascent_timetamp($auto_message->periodicity);

                
                if($auto_message->instant_publish == 0 && date('z-Y', $ascent) == date('z-Y', time()) && $ascent > time()) 

                {

                    unset($auto_messages[$k]);

                }

                else if($auto_message->instant_publish == 0 && $auto_message->last_publish_date > $ascent)

                {

                    unset($auto_messages[$k]);

                }

                else if(time() > $ascent && $ascent > $auto_message->last_publish_date || date('z-Y', $ascent) == date('z-Y', time())) 

                {

                    $auto_message->last_publish_date = $ascent;

                }

            }


        }


       // print_r($auto_messages);

        $mergedArray     = array_merge($auto_messages, $classicMessages);


        usort($mergedArray, function($a, $b) {

            return strcmp($b->last_publish_date, $a->last_publish_date);

        });


        $messages = array_splice($mergedArray, 0, $pagination_config['per_page']);


        //print_r($messages);

        $data['messages'] = $messages;


        $data['total_messages'] = $pagination_config['total_rows'];

        $data['offset']         = $offset;

        $data['limit']          = count($data['messages']);


        $this->load->view('user/inbox/inbox_home', $data);

    }


    private function is_not_allowed_user($private_message_id)

    {

        $id = $this->db->select('id')->where('user_id', $this->session->id)->where('parent_message_id', $private_message_id)->where('state', 0)->get('messages_users')->row()->id;

        if (empty($id)) {

            return true;

        }

        return false;


    }


    public function update_messages_status($action='')

    {

 
        $actions = ['deleted' => null, 'unreaded'  => ['txt' => 'marquer comme non-lu'] , 'readed' => ['txt' => 'marquer comme lu']];


        if ($this->input->method() == 'post' && array_key_exists($action, $actions)) 

        {

            $messages_data = $this->input->post('data');

            $messages_data = json_decode($messages_data, JSON_OBJECT_AS_ARRAY);


            $days = [null, 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'];

            
            $func = 'set_status_'.$action;


            if($action == 'deleted')

            {

                $regular_messages_id = array();

                $session_status = $this->session->status_auto_messages;

                $session_status = json_decode($session_status, JSON_OBJECT_AS_ARRAY);


                foreach($messages_data as $message)

                {

                    if($message['mtype'] == 'auto')

                    {

                        $result = $this->inbox_model->get_auto_message($message['mid'], 'messages_auto.id, messages_auto.type, messages_auto.periodicity, messages_auto.publish_date, messages_auto.publish_date');


                        # Message périodique

                        if($result->type == 1)

                        {

                            $ascent = Ygg::get_ascent_timetamp($result->periodicity);

                        }


                        $key = 'message_'.$result->id;


                        if(array_key_exists($key, $session_status) && $session_status[$key] == 'deleted')

                        {

                            $this->show_error('Certains des messages selectionnés ont déjà été supprimés');   

                        }

                        else if(array_key_exists($key, $session_status) && $session_status[$key] > $result->publish_date)

                        {

                            if($result->type == 1 && time() > $ascent && $session_status[$key] < $ascent)

                            {  

                              $this->show_error('Vous ne pouvez supprimer un message automatique qu\\'après l\\'avoir lu.');   

                            }

                            else

                            {

                                $session_status[$key] = 'deleted';

                            }

                        }

                        else 

                        {

                            $this->show_error('Vous ne pouvez supprimer un message automatique qu\\'après l\\'avoir lu.');   

                        }

                    }

                    else {

                        $regular_messages_id[] = $message['mid'];

                    }

                }


                $this->inbox_model->update_status_auto_message($session_status);

                $this->inbox_model->$func($regular_messages_id);


                $data = array(

                    'action' => 'success',

                    'data' => $session_status

                );

                $this->show_json($data);

            }

            else 

            {

                if(in_array('auto', array_column($messages_data, 'mtype')))

                {

                   $this->show_error('Impossible de '.$actions[$action]['txt'].' un message automatique.');   

                }

                else 

                {

                    $messages_id = array_column($messages_data, 'mid');


                    $this->inbox_model->$func($messages_id);


                    $this->show_json('success');

                }

            }

        }

    }


    public function get_ajax_replies()

    {

        $private_message = intval($this->input->post('pm', true));

        $offset          = intval($this->input->post('offset', true));


        if ($this->is_not_allowed_user($private_message)) {

            $this->send_message_error('Accès refusé vous n\\'avez pas l\\'autorisation');

        }


        $message_replies = $this->inbox_model->get_replies($private_message, 15, $offset);

        $out             = '';

        foreach ($message_replies as $reply) {

            $data['reply'] = $reply;

            $out .= $this->load->view('ajax_templates/private_message/reply', $data, true);

        }


        $this->output->set_content_type('application/json')->set_output(json_encode(array('html' => $out, 'length' => count($message_replies))));

    }


    public function edit_reply()

    {

        //    $this->output->enable_profiler();

        $reply_id = intval($this->input->post('id', true));


        if ($this->inbox_model->is_owner_reply($reply_id) && isset($reply_id)) {


            $this->form_validation->set_rules('reply_body', 'contenu du message', 'required|min_length[10]|max_length[4000]|xss_clean');


            if ($this->form_validation->run()) {

                $reply = $this->input->post('reply_body');

                $reply = purify($reply);

                $reply = htmlentities($reply);

                // Je suis un porc et j'assume !

                $this->db->where('id', $reply_id)->set('message_body', $reply)->update('messages_replies');

            }


            sizeof($this->form_validation->error_array()) > 0 ? $this->show_error(array_values($this->form_validation->error_array())[0]) : '';


        }


    }


    public function read_message_auto($message_auto_id = '')

    {

        $message = $this->inbox_model->get_auto_message($message_auto_id);

        $status_messages = $this->session->status_auto_messages;

        $status_messages = json_decode($status_messages, JSON_OBJECT_AS_ARRAY);

        
        if(count($status_messages) == 0 || !is_array($status_messages))

        {

            $status_messages = array();

        }


        $message_id = 'message_'.$message_auto_id;

        
        if($message->type == 1)

        {

            $ascent = Ygg::get_ascent_timetamp($message->periodicity);

        }


        if(!array_key_exists($message_id, $status_messages) || $status_messages[$message_id] < $message->publish_date 

            || ($message->type == 1 && time() > $ascent && $status_messages[$message_id] < $ascent))

        {

            $this->inbox_model->viewed_auto_message($message_auto_id);

            $this->inbox_model->increment_views_message_auto($message_auto_id);

        }


        $status_messages['message_'.$message_auto_id] = time();

        $this->inbox_model->update_status_auto_messages($status_messages);


        $data['auto_message'] = $message;

        $this->load->view('user/inbox/inbox_read_message_auto', $data);

    }


    public function get_message()

    {

        $message_id = $this->input->get('id');


        if (!filter_var($message_id, FILTER_VALIDATE_INT)) {

            $this->show_error('Paramètre message_id invalide');

        }


        $message = $this->inbox_model->get_reply_message($message_id);


        if (empty($message->id)) {

            $this->show_error('Message inexistant');

        }


        if ($message->publisher_id != $this->session->id) {

            $this->show_error('Impossible de charger un message qui ne vous appartient pas');

        }


        $this->load->helper('minify');


        $html = minify_html(html_entity_decode($message->message_body));

        $this->output->set_content_type('application/json')->set_output(json_encode(array('html' => $html)));

    }


    public function delete_action()

    {

        $del_type = $this->input->get('type');

        $tid      = intval($this->input->get('target_id'));


        if (isset($del_type) && isset($tid)) {

            // We want to "delete" an entire private message

            if ($del_type == 'private_message') {


                // We want to "delete" a reply

            } else if ($del_type == 'reply') {

                $this->inbox_model->is_owner_reply($tid) ? $this->inbox_model->delete_reply($tid) : '';

                // $this->action_success();

            }


        }

    }


    public function read_private_message()

    {

        // Send form action

        if ($_SERVER['REQUEST_METHOD'] == 'POST') {

            //   $this->form_validation->set_rules('message_object', 'objet du message', 'required');

            $this->form_validation->set_rules('reply_body', 'contenu du message', 'required|min_length[10]|max_length[4000]|xss_clean');

            $this->form_validation->set_rules('private_message_id', 'private_message_id', 'required|integer');


            if ($this->form_validation->run()) {


                $reply_body         = htmlentities(purify($this->input->post('reply_body')));

                $private_message_id = $this->input->post('private_message_id');


                if ($this->is_not_allowed_user($private_message_id)) {

                    $this->send_message_error('Accès refusé vous n\\'avez pas l\\'autorisation');

                }


                $reply_id = $this->inbox_model->new_reply($private_message_id, $reply_body);


                $this->load->helper('minify');


                $data['reply_body']         = $reply_body;

                $data['reply_id']           = $reply_id;

                $data['private_message_id'] = $private_message_id;

                // Buil ajax response

                $html = minify_html($this->load->view('ajax_templates/private_message/my_reply', $data, true));


                $this->output->set_content_type('application/json')->set_output(json_encode(array('html' => $html)));

            }


            // Handles form_validation errors in Json

            sizeof($this->form_validation->error_array()) > 0 ? $this->show_error(array_values($this->form_validation->error_array())[0]) : '';


        } else {

            $private_message_id = $this->input->get('id');


            $data['private_message'] = $this->inbox_model->get_private_message($private_message_id);


            if ($this->is_not_allowed_user($private_message_id)) {

                $this->send_message_error('Acces refusé vous n\\'avez pas l\\'autorisation');

            } else {

                $data['private_replies_message'] = $this->inbox_model->get_replies($private_message_id);

                $data['count_replies']           = $this->inbox_model->get_count_replies($private_message_id);


                $this->inbox_model->mark_as_read($private_message_id);

            }


            $this->load->view('user/inbox/inbox_read_message', $data);

        }

    }


    public function report_message()

    {

        if ($_SERVER['REQUEST_METHOD'] == 'POST') {

            //  $this->output->enable_profiler();

            $message_id    = intval($this->input->post('message_id'));

            $del_message   = $this->input->post('del_message');

            $ignore_sender = $this->input->post('ignore_sender');

            $reason        = $this->input->post('reason');


            $private_message_data = $this->inbox_model->getMessageDataFromReply('publisher_id, parent_message_id', $message_id);

            $publisher_id         = $private_message_data->publisher_id;

            $private_message_id   = $private_message_data->parent_message_id;


            if (isset($_POST['ignore_sender'])) {

                $ignoredList = $this->db->select('ignored')->where('id', $this->session->id)->get('users')->row()->ignored;

                $ignoredList = json_decode($ignoredList, JSON_OBJECT_AS_ARRAY);


                if (!array_key_exists($publisher_id, $ignoredList)) {

                    $isUserExists = $this->db->select('id')->where('id', $publisher_id)->get('users')->num_rows() > 0;


                    if ($isUserExists) {


                        // On ajoute l'utilisateur à la liste avec la date d'ajout

                        if (!is_array($ignoredList)) {

                            $ignoredList                = array();

                            $ignoredList[$publisher_id] = now();

                        } else {

                            $ignoredList[$publisher_id] = now();

                        }


                        $ignoredList = json_encode($ignoredList);

                        $this->db->where('id', $this->session->id)->set('ignored', $ignoredList)->update('users');

                    }


                }


                if (isset($_POST['del_message'])) {

                    $this->inbox_model->remove_private_messages(array($private_message_id));

                }


                if (isset($reason) && strlen($reason)) {

                    $this->show_error('le motif du signalement excède 250 caractères');

                }


            }

        }

    }


    public function send_message()

    {

        $recipient_id = $this->input->get('recipient_id');


        $data['single_recipient'] = false;


        if (isset($recipient_id) && filter_var($recipient_id, FILTER_VALIDATE_INT)) {

            // If users try to send a PM to itself

            if ($recipient_id == $this->session->id) {

                $this->action_send_message('Impossible de s\\'envoyer un message à soit même');

            } else {

                $recipient_nickname = $this->inbox_model->get_recipient_nickname($recipient_id);

                // If ID user doesn't exists

                if (empty($recipient_nickname)) {

                    $this->action_send_message('Cet identifiant utilisateur n\\'existe pas');

                } else {

                    $data['single_recipient_id']       = $recipient_id;

                    $data['single_recipient_nickname'] = $recipient_nickname;

                    $data['single_recipient']          = true;

                }

            }

        }

        // Send form action

        if ($_SERVER['REQUEST_METHOD'] == 'POST') {

            $this->action_send_message($data['single_recipient']);

        } else {

            $this->load->view('user/inbox/inbox_new_message', $data);

        }

    }


    private function action_send_message($single_recipient = false)

    {

        $this->form_validation->set_rules('recipients[]', 'destinataires', 'integer|required');


        // Set validation rules

        $this->form_validation->set_rules('message_object', 'objet du message', 'required|xss_clean');

        $this->form_validation->set_rules('message_body', 'contenu du message', 'required');


        if ($this->form_validation->run()) {

            // Get values

            $recipients     = array_map('intval', $this->input->post('recipients'));

            $message_object = strip_tags($this->input->post('message_object'));

            $message_body   = htmlentities(purify($this->input->post('message_body')));


            if (count($recipients) > 5) {

                $this->show_error('Impossible d\\'envoyer un MP à plus de 5 destinataires');

            }


            if (in_array($this->session->id, $recipients)) {

                $this->show_error('Impossible de s\\'inclure dans la liste des destinataires');

            }


            $recipients_list = $this->inbox_model->get_recipients_list($recipients);

            // Add the current session user to recipients list

            $recipient_self->id           = $this->session->id;

            $recipient_self->nickname     = $this->session->nickname;

            $recipient_self->is_expeditor = true;

            $recipients_list[]            = $recipient_self;


            $recipients_list_id = array();


            $seconds = array(

                '24hours' => 3600,

                '4days'   => 345600,

                '1week'   => 604800,

                '2weeks'  => 1209600,

                '1month'  => 2629746,

                '3months' => 7889238,

            );


            foreach ($recipients_list as $recipient) {

                if ($recipient->id != $this->session->id) {

                    $recipient_settings = json_decode($recipient->settings, JSON_OBJECT_AS_ARRAY);

                    $ignoredList        = json_decode($recipient->ignored, JSON_OBJECT_AS_ARRAY);


                    if (array_key_exists($this->session->id, $ignoredList)) {

                        $this->show_error('Impossible de communiquer avec l\\'utilisateur <strong>' . $recipient->nickname . '</strong>');

                    } else if (isset($recipient_settings['pm']['condition_sender_age']) && $recipient_settings['pm']['condition_sender_age'] != 'nocondition') {

                        $sender_age = $recipient_settings['pm']['condition_sender_age'];


                        $timestamp_pm = now() - $seconds[$sender_age];


                        if ($this->session->join_date >= $timestamp_pm) {

                            $this->show_error('L\\'ancienneté de votre compte ne vous permet pas de communiquer avec l\\'utilisateur <strong>' . $recipient->nickname . '</strong>');

                        }

                    } else if ($recipient_settings['pm']['enable'] != 1) {

                        $this->show_error('<strong>' . $recipient->id . '</strong> a désactivé sa boite de réception et ne souhaite pas recevoir de nouveaux messages');

                    }


                    $recipients_list_id[] = $recipient->id;

                }

            }


            // Verify if recipients are valids

            if (count(array_diff($recipients, $recipients_list_id)) != 0) {


                $this->show_error('La liste des destinataires est invalide');

            }


            // Create private message

            $private_message_id = $this->inbox_model->new_private_message($message_object, $recipients_list);


            // Add reply

            $this->inbox_model->new_reply($private_message_id, $message_body);


            $this->session->set_flashdata('pm_sent', true);


            $this->output->set_content_type('application/json')->set_output(json_encode(array('message_id' => $private_message_id)));

        }


        // Handles form_validation errors in Json

        sizeof($this->form_validation->error_array()) > 0 ? $this->show_error(array_values($this->form_validation->error_array())[0]) : '';

    }


    public function search_users()

    {

        $queryP = $this->input->get('q', true);


        $list = array();


        if (!empty($queryP) && strlen($queryP) >= 3) {

            $query = 'SELECT * FROM users WHERE MATCH(\\'@nick ' . $this->_escape($queryP . '*') . '| ' . $this->_escape($queryP) . ' \\') limit 10';

            // Open Sphinx connection

            $conn = new mysqli($this->config->item('sphinx_server'), null, null, null, $this->config->item('sphinx_server_port'));


            if ($conn->connect_error) {

                throw new Exception('Erreur avec Sphinx : ' . $conn->connect_error, $conn->connect_error);

            }


            $query_search = $conn->query($query);

            $results      = array();

            // Retrieve the Ids

            while ($row = $query_search->fetch_assoc()) {

                $results[] = $row['id'];

            }


            $query_search->free_result();

            $ids = join('\\',\\'', $results);

            // Mysql query to get the nicknames

            // id, avatar, rank, uploaded, downloaded, last_activity_date, nickname, country

            $sql = "SELECT id, avatar, rank, uploaded, downloaded, last_activity_date, nickname, country FROM users WHERE id IN ('$ids') ORDER BY FIELD (users.id,'$ids')";


            $results = $this->db->query($sql)->result();


            foreach ($results as $result) {

                $list[] = ['id' => $result->id, 'text' => $result->nickname];

            }

        }


        $this->output->set_content_type('application/json')->set_output(json_encode($list));

    }


    public function can_receive()

    {

        $user_id = intval($this->input->get('user_id', true));


        if (isset($user_id)) {

            if ($this->session->id == $user_id) {

            	 $this->output->set_content_type('application/json');

                $this->output->set_output(json_encode(array('response' => 'negative', 'msg' => 'Impossible de s\\'inclure dans la liste des destinataires')));

            } else {

                $recipient_data = $this->db->select('nickname, settings, ignored')->where('id', $user_id)->get('users')->row();

                $nickname       = $recipient_data->nickname;


                $recipient_settings = json_decode($recipient_data->settings, JSON_OBJECT_AS_ARRAY);

                $ignoredList        = json_decode($recipient_data->ignored, JSON_OBJECT_AS_ARRAY);


                if (array_key_exists($this->session->id, $ignoredList)) {

                    $this->output->set_content_type('application/json')->set_output(json_encode(array('response' => 'negative', 'msg' => 'Impossible de communiquer avec l\\'utilisateur <strong>' . $nickname . '</strong>')));

                } else {

                    if ($recipient_settings['pm']['enable'] != 1) {

                        $this->output->set_content_type('application/json')->set_output(json_encode(array('response' => 'negative', 'msg' => '<strong>' . $nickname . '</strong> a désactivé sa boite de réception et ne souhaite pas recevoir de nouveaux messages')));

                    } else if (isset($recipient_settings['pm']['condition_sender_age']) && $recipient_settings['pm']['condition_sender_age'] != 'nocondition') {

                        $sender_age = $recipient_settings['pm']['condition_sender_age'];


                        $seconds = array

                            (

                            '24hours' => 3600,

                            '4days'   => 345600,

                            '1week'   => 604800,

                            '2weeks'  => 1209600,

                            '1month'  => 2629746,

                            '3months' => 7889238,

                        );


                        $timestamp_pm = now() - $seconds[$sender_age];


                        if ($this->session->join_date >= $timestamp_pm) {

                            $this->output->set_content_type('application/json');

                            $this->output->set_output(json_encode(array('response' => 'negative', 'msg' => 'L\\'ancienneté de votre compte ne vous permet pas de communiquer avec l\\'utilisateur <strong>' . $recipient->nickname . '</strong>')));

                        }

                    }

                }

            }

        }

    }


    private function send_message_error($error)

    {

        $this->session->set_flashdata('send_message_error', $error);

        // It redirects on error

        redirect(site_url('user_messaging'));

    }


}