<?php

namespace Modules\Sms\Http\Controllers;

use Excel;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
use Log;
use Modules\Leads\Entities\Lead;
use Modules\Platform\Core\Entities\CsvData;
use Modules\Platform\Core\Helper\Excel\RecordImport;
use Modules\Platform\Core\Http\Controllers\ModuleCrudController;
use Modules\Platform\Core\Http\Requests\CsvImportRequest;
use Modules\Platform\Core\Repositories\GenericRepository;
use Modules\Platform\User\Entities\User;
use Modules\Sms\Datatables\SmsDatatable;
use Modules\Sms\Entities\Sms;
use Modules\Sms\Entities\SmsSender;
use Modules\Sms\Http\Form\SmsForm;
use Modules\Sms\Http\Requests\CreateSmsRequest;
use Modules\Sms\Service\SmsService;

class SmsController extends ModuleCrudController
{
    protected $datatable = SmsDatatable::class;
    protected $formClass = SmsForm::class;
    protected $storeRequest = CreateSmsRequest::class;
    protected $updateRequest = CreateSmsRequest::class;
    protected $entityClass = Sms::class;

    protected $disableNextPrev = false;
    protected $showMassActionButtons = false;

    protected $moduleName = 'sms';
    protected $languageFile = 'sms::sms';

    protected $permissions = [
        'browse' => 'sms.browse',
        'create' => 'sms.create',
        'update' => 'sms.update',
        'destroy' => 'sms.destroy'
    ];

    protected $jsFiles = [
        'BAP_Sms.js',
        'countSms.js',
    ];

    protected $routes = [
        'index' => 'sms.sms.index',
        'create' => 'sms.sms.create',
        'show' => 'sms.sms.show',
        'edit' => 'sms.sms.edit',
        'store' => 'sms.sms.store',
        'destroy' => 'sms.sms.destroy',
        'update' => 'sms.sms.update',
        'import' => 'sms.sms.import',
        'import_process' =>  'sms.sms.import.process'
    ];

    protected $moduleSettingsLinks = [
        ['route' => 'sms.sender.index', 'label' => 'settings.sender'],
    ];
    // protected $settingsPermission = 'sms.settings';


    public function __construct()
    {
        parent::__construct();
    }
    
    protected $showFields = [

        'sms_information' => [

            'receiver' => ['type' => 'text', 'col-class' => 'col-lg-4'],
            // 'sms_sender_id' => [
            //     'type' => 'manyToOne',
            //     'relation' => 'smsSender',
            //     'column' => 'name',
            //     'col-class' => 'col-lg-4'
            // ],
            'smsLength' => ['type' => 'text', 'col-class' => 'col-lg-4'],
            'smsLength' => ['type' => 'text', 'col-class' => 'col-lg-4'],
            'status' => ['type' => 'text', 'col-class' => 'col-lg-4'],

            'senttime' => [
                'type' => 'datetime',
                'col-class' => 'col-lg-4'
            ],
            'campaign_id' => [
                'type' => 'manyToOne',
                'relation' => 'campaign',
                'column' => 'name',
                'dont_translate' => true,
                'col-class' => 'col-lg-4 col-md-4 col-sm-6 col-xs-6'
            ],
            'account_id' => [
                'type' => 'manyToOne',
                'relation' => 'referral',
                'column' => 'account',
                'dont_translate' => true,
                'col-class' => 'col-lg-4 col-md-4 col-sm-6 col-xs-6'
            ],
            'lead_id' => [
                'type' => 'manyToOne',
                'relation' => 'lead',
                'column' => 'full_name',
                'dont_translate' => true,
                'col-class' => 'col-lg-4 col-md-4 col-sm-6 col-xs-6'
            ],
            'contact_id' => [
                'type' => 'manyToOne',
                'relation' => 'contact',
                'column' => 'full_name',
                'dont_translate' => true,
                'col-class' => 'col-lg-4 col-md-4 col-sm-6 col-xs-6'
            ],           

        ],

        'description' => [
            'msg' => ['type' => 'text', 'col-class' => 'col-lg-12 col-md-12 col-sm-12'],
            'character_count' => ['type' => 'static', 'hide_in_edit'=>true, 'hide_in_show'=>true],
            'notes' => ['type' => 'text', 'col-class' => 'col-lg-12 col-md-12 col-sm-12'],
        ],

    ];

    protected function indexActionButtons()
    {
        $noPermissionIsRequired = (array_key_exists('create', $this->permissions) && $this->permissions['create'] == '');
        $hasPermissionifRequired = (isset($this->permissions['create']) && $this->permissions['create'] != '' && \Auth::user()->hasPermissionTo($this->permissions['create']));

        if ($noPermissionIsRequired || $hasPermissionifRequired) {

            // $this->indexActionButtons[] = array(
            //     'href' => route('sms.sms.createBulk'),
            //     'attr' => [
            //         'class' => ['Create Bulk']
            //     ],
            //     'label' => 'Create Bulk'
            // );
            $this->indexActionButtons[] = array(
                'href' => '#',
                'attr' => [
                    'class' => ['quick_create']
                ],
                'label' => trans('core::core.btn.quick_create')
            );
            if (isset($this->routes['import'])) {
                $this->indexActionButtons[] = array(
                    'href' => '#',
                    'attr' => [
                        'class' => ['records_import']
                    ],
                    'label' => 'Bulk SMS'
                );
            }

        }
        
    }

    protected function importProcess(Request $request)
    {
        ini_set('max_execution_time', 0);

        $data = CsvData::find($request->get('file_id'));

        if (empty($data)) {
            flash(trans('core::core.cannot_process_import'))->error();
            return redirect()->route($this->routes['index']);
        }

        $csvData = json_decode($data->csv_data, true);
        $requestFields = $request->get('fields');
        $imported = 0;
        $notImported = 0;

        unset($csvData[0]); // remove header

        foreach ($csvData as $row) {
            try {
                $fields = [];
                foreach ($requestFields as $key => $field) {
                    $fields[$field] = $row[$key];
                }

                (new SmsService())->sendAndSave($fields['msg'], $fields['receiver'], $fields);
                $imported++;

            } catch (\Exception $exception) {
                $notImported++;
                Log::error($exception);
            }
        }

        flash(trans('core::core.import_finished', ['imported' => $imported, 'not_imported' => $notImported, 'updated' => 0]))->info();
        return redirect()->route($this->routes['index']);
    }


    protected function import(CsvImportRequest $request)
    {


        try {

            if (\Auth::user()->hasPermissionTo($this->permissions['create'])) {

                $path = $request->file('csv_file');

                $importConfig = [
                    'delimiter' => $request->get('delimiter')
                ];

                $data = Excel::toArray(new RecordImport($importConfig), $path);

                $data = $data[0];

                if (count($data) > 0) {

                    $view = view($this->views['import']);

                    $csv_header_fields = [];
                    foreach ($data[0] as $value) {
                        $csv_header_fields[$value] = $value;
                    }

                    foreach ($data as &$row) {
                        $row = array_combine($csv_header_fields, $row);
                    }

                    $view->with('csv_header', $csv_header_fields);

                    $csvDataFile = CsvData::create([
                        'csv_filename' => $request->file('csv_file')->getClientOriginalName(),
                        'csv_header' => 1,
                        'csv_data' => json_encode($data)
                    ]);


                    $csvData = array_slice($data, 0, 2);

                    $moduleFields = \App::make($this->entityClass)->fillable;

                    $moduleFields = CrudHelper::removeValues($moduleFields, [
                        'id', 'company_id', 'full_name','msgId','smsLength',
                        'smsCost', 'senttime', 'smstype','status','notes',
                        'isDone', 'sms_sender_id', 'lead_id','account_id','contact_id','campaign_id'
                    ]);

                    $view->with('csvDataFile', $csvDataFile);
                    $view->with('module_fields', $moduleFields);
                    $view->with('csv_data', $csvData);

                    return $view;
                } else {

                    flash(trans('core::core.empty_file'))->error();

                    return redirect()->back();
                }

            }

            flash(trans('core::core.you_dont_have_access'))->error();
            return redirect()->route($this->routes['index']);

        } catch (\Exception $exception) {
            flash(trans('core::core.invalid_file'))->error();
        }

    }

    public function beforeStore($request, $storeValues = null)
    {
        if (empty($storeValues['receiver']) && !empty($storeValues['contact_id'])) {
            $contact = \Modules\Contacts\Entities\Contact::findOrFail($storeValues['contact_id']);
            if ($contact) {
                if ($contact->phone == null && $contact->mobile == null) {
                    return ['error' => 'Contact does not have a phone number!'];
                }
                $storeValues['receiver'] = $contact->phone != null ? $contact->phone : $contact->mobile;
            } else {
                return ['error' => 'Contact not found!'];
            }
        }
        if (!empty($storeValues['lead_id']) && empty($storeValues['receiver'])) {
            $lead = Lead::findOrFail($storeValues['lead_id']);
            if ($lead) {
                if ($lead->phone == null && $lead->mobile == null) {
                    return ['error' => 'Lead does not have a phone number!'];
                }
                $storeValues['receiver'] = $lead->phone != null ? $lead->phone : $lead->mobile;
            } else {
                return ['error' => 'Lead not found!'];
            }
        }

        $msgLength = mb_strlen($storeValues['msg'], 'UTF-8');
        if (preg_match('/\p{Arabic}/u', $storeValues['msg'])) {
            if ($msgLength > 402) {
                return ['error' => 'SMS Message is too long!'];
            }
        } else {
            if ($msgLength > 918) {
                return ['error' => 'SMS Message is too long!'];
            }
        }

        return $storeValues;
    }

    public function store()
    {
        $request = \App::make($this->storeRequest ?? Request::class);

        $mode = $request->get('entityCreateMode', self::FORM_MODE_FULL);

        if ($this->demoMode) {
            if (config('bap.demo')) {

                if ($mode == self::FORM_MODE_FULL) {
                    flash(trans('core::core.you_cant_do_that_its_demo'))->error();
                    return redirect()->back();
                } else {
                    return response()->json([
                        'type' => 'error',
                        'message' => trans('core::core.you_cant_do_that_its_demo'),
                        'action' => 'refresh_datatable'
                    ]);
                }

            }
        }

        if ($this->permissions['create'] != '' && !\Auth::user()->hasPermissionTo($this->permissions['create'])) {
            if ($mode == self::FORM_MODE_SIMPLE) {
                return response()->json([
                    'type' => 'error',
                    'message' => trans('core::core.entity.you_dont_have_access'),
                    'action' => 'show_message'
                ]);
            }
            flash(trans('core::core.you_dont_have_access'))->error();
            return redirect()->route($this->routes['index']);
        }

        $storeValues = $this->form($this->formClass)->getFieldValues(true);

        if( key_exists('full_name', $storeValues) && $storeValues['full_name'] == NULL ){
            $storeValues['full_name'] = $storeValues['first_name'] ." ". $storeValues['last_name'];
        }

        if ($mode == self::FORM_MODE_SIMPLE) {

            //Bind related element
            $relatedEntityId = $request->get('relatedEntityId');
            $relationType = $request->get('relationType', null);
            $relatedField = $request->get('relatedField');
            $relatedEntity = $request->get('relatedEntity');

            if ($relationType != null) { // Relation type is not null


                $relationEntityRepos = \App::make(GenericRepository::class);
                $relationEntityRepos->setupModel($relatedEntity);

                $relationEntity = $relationEntityRepos->findWithoutFail($relatedEntityId);

                if ($relationType == 'oneToMany') {
                    $storeValues[$relatedField] = $relationEntity->id;
                }
            }
        }

        $beforeStoreRespons = $this->beforeStore($request,$storeValues);
        if(isset($beforeStoreRespons['error'])){
            if ($mode == self::FORM_MODE_SIMPLE) {
                return response()->json([
                    'type'    => 'error',
                    'message' => $beforeStoreRespons['error'],
                    'action'  => 'show_message'
                ]);
            }
            flash($beforeStoreRespons['error'])->error();
            return redirect(route($this->routes['create']));
        }
        $storeValues = $beforeStoreRespons;

        $extra = array_intersect_key($storeValues, array_flip(['lead_id', 'contact_id', 'campaign_id', 'account_id', 'notes', 'sms_sender_id', 'company_id']));
        $entity = (new SmsService())->sendAndSave($storeValues['msg'], $storeValues['receiver'], $extra);

        $entity = $this->setupAssignedTo($entity, $request, true);
        $entity->save();


        if (config('bap.record_assigned_notification_enabled')) {

            if ($entity instanceof Ownable) {
                if ($entity->getOwner() != null && $entity->getOwner() instanceof User) {
                    if ($entity->getOwner()->id != \Auth::user()->id) { // Dont send notification for myself
                        try {
                            $commentOn = $entity->name;
                            $commentOn = ' - ' . $commentOn;
                        } catch (\Exception $exception) {
                            $commentOn = '';
                        }

                        $placeholder = new NotificationPlaceholder();

                        $placeholder->setRecipient($entity->getOwner());
                        $placeholder->setAuthorUser(\Auth::user());
                        $placeholder->setAuthor(\Auth::user()->name);
                        $placeholder->setColor('bg-green');
                        $placeholder->setIcon('assignment');
                        $placeholder->setContent(trans('notifications::notifications.new_record', ['user' => \Auth::user()->name]) . $commentOn);

                        $placeholder->setUrl(route($this->routes['show'], $entity->id));

                        // Ahmed abdo - diable sending email for solving error
                        // $entity->getOwner()->notify(new GenericNotification($placeholder));
                    }
                }
            }
        }

        if ($mode == self::FORM_MODE_SIMPLE) {

            //Bind related element
            $relatedEntityId = $request->get('relatedEntityId');
            $relationType = $request->get('relationType', null);
            $relatedField = $request->get('relatedField');
            $relatedEntity = $request->get('relatedEntity');

            if ($relationType != null) { // Relation type is not null

                $relationEntityRepos = \App::make(GenericRepository::class);
                $relationEntityRepos->setupModel($relatedEntity);


                $relationEntity = $relationEntityRepos->findWithoutFail($relatedEntityId);


                if ($relationType == 'manyToMany') {
                    $entity->{$relatedField}()->attach($relationEntity->id);
                }
            }

            return response()->json([
                'type' => 'success',
                'message' => trans('core::core.entity.created'),
                'action' => 'refresh_datatable'
            ]);
        }

        flash(trans('core::core.entity.created'))->success();

        return redirect(route($this->routes['index']));
    }

    public function createBulk(Request $request)
    {
        if ($this->permissions['create'] != '' && !\Auth::user()->hasPermissionTo($this->permissions['create'])) {
            flash(trans('core::core.you_dont_have_access'))->error();
            return redirect()->route($this->routes['index']);
        }

        $this->beforeCreate($request);
        $this->setupCreateFormData();

        $fillModel = $request->all();

        $fillModel = array_merge($fillModel, $this->createFormData);


        $action = $request->get('action', null);

        $copy = $request->get('copy', null);
        if ($copy) {

            $repository = $this->getRepository();

            $copyFrom = $repository->findWithoutFailForCopy((int)$copy);

            if (!empty($copy)) {
                $fillModel = $copyFrom;
            }
        }

        $url = route($this->routes['store']);

        if (self::ACTION_MASS_UPDATE == $action) {
            $url = route($this->moduleName . '.' . $this->moduleName . '.mass_update');
        }

        $createForm = $this->form($this->formClass, [
            'method' => 'POST',
            'url' => $url,
            'id' => 'module_form',
            'model' => $fillModel
        ]);


        $createView = $this->views['create'];

        $mode = $request->get('mode', 'full');

        if ($mode == self::FORM_MODE_SIMPLE) {
            $createView = 'core::crud.module.create_form';
        }

        $view = view($createView);
        $view->with('entity', null);
        $view->with('modal_form', false);

        if ($mode == self::FORM_MODE_SIMPLE) {
            $formId = uniqid('form_');

            $view->with('modal_form', true);
            $createForm->setFormOption('id', $formId);
            if ($this->formModalCssClass != null && $request->get('relationType') === null && !$request->get('quickEditModel')) {
                $createForm->setFormOption('class', $this->formModalCssClass);
            } else {
                $createForm->setFormOption('class', 'module_form related-modal-form');
            }
            if ($this->formModalCssId != null) {
                $createForm->setFormOption('id', $this->formModalCssId);
            }

            $view->with('formId', $formId);
            $createForm->add('entityCreateMode', 'hidden', [
                'value' => 'modal'
            ]);
            $createForm->add('relationType', 'hidden', [
                'value' => $request->get('relationType')
            ]);
            $createForm->add('relatedField', 'hidden', [
                'value' => $request->get('relatedField')
            ]);
            $createForm->add('relatedEntityId', 'hidden', [
                'value' => $request->get('relatedEntityId')
            ]);

            $createForm->add('relatedEntity', 'hidden', [
                'value' => $request->get('relatedEntity')
            ]);

            if (self::ACTION_MASS_UPDATE == $action) {
                $createForm->add('mass_action_ids', 'hidden', [
                    'value' => '',

                ]);
                $createForm->setFormOption('class', "module_form related-modal-form mass_update_form");
            }
        }

        $view->with('form_request', $this->storeRequest);
        $view->with('sectionButtons', $this->sectionButtons);

        if (self::ACTION_MASS_UPDATE == $action) {
            $view->with('form_request', null);
            $view->with('massUpdateMode', true);

            foreach ($createForm->getFields() as $field) {

                if (isset($field->getOptions()['removeFromMassUpdate']) && $field->getOptions()['removeFromMassUpdate']) {
                    $createForm->remove($field->getName());

                    $this->showFields = array_map(function (array $elem) use ($field) {
                        unset($elem[$field->getName()]);
                        return $elem;
                    }, $this->showFields);
                }
            }

            $this->showFields = array_filter($this->showFields);

        } else {
            $view->with('massUpdateMode', false);
        }

        $view->with('show_fields', $this->showFields);


        return $view->with('form', $createForm);
    }
}