<?php

namespace App\Repositories;

use App\Models\ScheduleEmail;
use Illuminate\Support\Facades\Validator;
use Illuminate\Http\Request;
use App\Support\Query;
use Illuminate\Support\Facades\DB;
use App\Models\File;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Storage;


use Log;

class ScheduleEmailRepository extends Repository
{
    public function __construct($event = null)
    {
        $this->for($event);
    }


    public function model(): ?ScheduleEmail
    {
        return new ScheduleEmail;
    }

    public function query($as = null)
    {
        $model = $this->model();
        return $model->newQuery();
    }

    public function saveEmail($request, $event)
    {
        $data = $request->get('data');
        // data 
        $data = json_decode($data, true);
        // validation
        $validator = Validator::make($data, [
            'recipients' => ['required'],
            'subject' => ['string', 'max:255'],
            'body' => ['string', 'nullable'],
            'attachment' => ['array', 'nullable'],
        ]);
        if ($validator->fails()) {
            validationErrorResponse($validator->errors());
        }
        else {
            $data['filter']['recipients'] = $data['recipients'];
            $data['filter']['interval'] = [
                "interval" => @$data['interval'],
                "interval_day" => (isset($data['interval_day'])) ? $data['interval_day'] : "",
                "interval_month_number" => (isset($data['interval_month_number'])) ? $data['interval_month_number'] : "",
                "interval_day_number" => (isset($data['interval_day_number'])) ? $data['interval_day_number'] : "",
                "interval_time" => @$data['interval_time'],
            ];
            $emailData = [
                'email_status' => 0,
                'email_type' => $data['email_type'],
                'filter' => json_encode($data['filter']),
                'subject' => isset($data['subject']) ? $data['subject'] : '',
                'submission_status' => $data['submission_status'],
                'body' => isset($data['body']) ? $data['body'] : '',
                'send_date' => Null,
            ];

            $emailId = $data['email_id'];
            $emailType = (isset($data['schedule_type'])) ? $data['schedule_type'] : "new";

            if ($emailId && $data['submission_status'] != 1 && $emailType != "Instant") {
                $emailData['submission_status'] = $data['submission_status'];
                // unset($emailData['email_status']);
                $email = ScheduleEmail::find($emailId);
                $email = $email->fill($emailData);
                $email->save();
                $attachmentData = $this->handleEmailFiles($request, $email, $data);
                $email->attachments = $attachmentData;
                $email->save();
                return response([
                    'status' => true,
                    'message' => "Mail updated Successfully",
                    'email' => $email
                ]);
            }
            else if ($emailId && $emailType == "Draft") {
                $emailData['submission_status'] = $data['submission_status'];
                // unset($emailData['email_status']);
                $email = ScheduleEmail::find($emailId);
                $email = $email->fill($emailData);
                $email->save();
                $attachmentData = $this->handleEmailFiles($request, $email, $data);
                $email->attachments = $attachmentData;
                $email->save();

                if ($data['submission_status'] == 1) {
                    Artisan::call('schedule:email ' . $email->id);
                }
                return response([
                    'status' => true,
                    'message' => "Mail updated Successfully",
                    'email' => $email
                ]);
            }
            else {
                $email = new ScheduleEmail([
                    'event_id' => $event->id,
                ]);

                $email = $email->fill($emailData);
                $email->save();
                $attachmentData = $this->handleEmailFiles($request, $email, $data);
                $email->attachments = $attachmentData;
                $email->save();
                if ($data['submission_status'] == 1) {
                    Artisan::call('schedule:email ' . $email->id);
                }
                return response([
                    'status' => true,
                    'message' => "Mail Created Successfully",
                    'email' => $email
                ]);
            }
        }
    }
    public function handleEmailFiles(Request $request, ScheduleEmail $email, $data)
    {

        $attachmentData = $data['attachments'];
        //handling uploaded files
        if ($request->hasFile('attachments')) {
            $files = $request->file('attachments');
            $fileContents = [];
            foreach ($files as $file) {
                $fileObj = $email->saveFile(
                    $file,
                    null,
                    "{$email->id}/files/",
                    "schedule_email.file",
                    null,
                    true
                );
                $fileContents[] = $fileObj->getFileObject();
            }

            $attachmentData = array_values(array_filter(array_merge($data['attachments'], $fileContents)));
        }

        //handling removed files
        $removedFiles = $data['removed_files'];

        if (isset($removedFiles)) {
            $fileIds = $removedFiles;
            foreach ($fileIds as $fileId) {

                $this->deleteFile($fileId);
            }
        }

        return $attachmentData;
    }

    public function scope($arguments, $callback = null)
    {
        //get query builder
        $query = $this->query()
            ->select($this->selectColumns());

        //applying different scopes based on the arguments
        $this->applyScope($query, $arguments);

        //resolve if there is any callback functions available
        return $this->resolve($query, $arguments, $callback);
    }


    public function applyScope(Builder $query, $arguments): Builder
    {
        $this->applyEventScope($query, $arguments);

        $this->applyOrder($query, $arguments);

        $this->applySearch($query, $arguments);

        return $query;
    }

    public function applyEventScope(Builder $query, $arguments): Builder
    {
        if ($arguments->event) {

            $query->where('schedule_emails.event_id', '=', $arguments->event->id);
        }

        return $query;
    }


    public function applyOrder(Builder $query, Query $arguments): Builder
    {
        $emailColumns = [
            'subject' => 'schedule_emails.subject',
            'email_type' => 'schedule_emails.email_type',
            'email_status' => 'schedule_emails.email_status',
            'send_date' => 'schedule_emails.send_date',
            'submission_status' => 'schedule_emails.submission_status'
        ];

        $sorts = json_decode($arguments->sort, true) ?? [];
        foreach ($sorts as $sort => $method) {
            if (array_key_exists($sort, $emailColumns)) {
                $query->orderBy($sort, $method);
            }
        }

        return $query;
    }


    public function applySearch(Builder $query, $arguments): Builder
    {
        if ($arguments->search) {
            $emailColumns = [
                'title' => 'schedule_emails.subject',
                'type' => 'schedule_emails.email_type',
                'email_status' => 'schedule_emails.email_status',
                'submission_status' => 'schedule_emails.submission_status',

            ];
            $search = strtolower($arguments->search);
            $query->where(function ($query) use ($search, $emailColumns) {
                foreach ($emailColumns as $key => $emailColumn) {
                    if ($key == 'email_status') {
                        $query->orWhere(DB::raw("CASE 
                        WHEN schedule_emails.email_status = 0 THEN 'pending' 
                        WHEN schedule_emails.email_status = 1 THEN 'success' 
                        WHEN schedule_emails.email_status = 2 THEN 'Failed' 
                        ELSE  'Failed (No valid data)' END"), 'like', "%{$search}%");
                    }
                    else if ($key == 'submission_status') {
                        $query->orWhere(DB::raw("CASE 
                        WHEN schedule_emails.submission_status = 0 THEN 'schedule'
                        WHEN schedule_emails.submission_status = 2 THEN 'draft'  
                        ELSE  'instant' END"), 'like', "%{$search}%");
                    }
                    else {
                        $query->orWhere(DB::raw("lower($emailColumn)"), 'like', "%{$search}%");
                    }
                }
            });
        }

        return $query;
    }
    public function selectColumns(): array
    {
        return [
            "schedule_emails.id",
            "schedule_emails.event_id",
            DB::raw("CASE 
                WHEN schedule_emails.email_status = 0 THEN 'Pending' 
                WHEN schedule_emails.email_status = 1 THEN 'Success' 
                WHEN schedule_emails.email_status = 2 THEN 'Failed' 
                ELSE  'Failed (No valid data)' END as email_status"),
            DB::raw("CASE 
                WHEN schedule_emails.submission_status = 0 THEN 'Schedule' 
                WHEN schedule_emails.submission_status = 2 THEN 'Draft' 
                ELSE  'Instant' END as schedule_type"),
            "schedule_emails.email_type",
            "schedule_emails.filter",
            "schedule_emails.subject",
            "schedule_emails.body",
            "schedule_emails.attachments",
            "schedule_emails.send_date"
        ];
    }


    public function listing($request, $paginate)
    {
        //building arguments
        $arguments = $this->arguments($request);

        //building query
        $query = $this->scope($arguments);

        return ($paginate && $arguments->paging != 'All') ? $query->paginate($arguments->paging, ['*'], 'page', $arguments->page) : $query->get();
    }
    public function fetchSingleEmail($id, $role = null, $request)
    {
        // event
        $event = $request->get('event');

        $email = ScheduleEmail::select($this->selectColumns())->find($id);

        if (!$email)
            return null;
        return $email;
    }

    public function delete(ScheduleEmail $email)
    {
        // delete if there is any attachments
        if (isset($email->attachments)) {
            foreach ($email->attachments as $attachment) {

                $this->deleteFile($attachment['file_id']);
            }
        }

        //delete directory
        Storage::deleteDirectory('private/media/schedule_emails/' . $email->id);
        $email->delete();
    }

}