<?php

namespace App\Services;

use App\Models\EventCalendar;
use App\Models\ParkingPattern;
use App\Models\ParkingPatternSpace;
use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;

class EventCalendarService extends BaseService
{

    private static array $statusArr
        = [
            'planned',
            'running',
            'ended',
            'disabled'
        ];


    public function __construct(OperationLogService $logService)
    {
        parent::__construct($logService);
        $this->logService->menuTitle = 'event_calendar';
    }

    /**
     * @return array|string[]
     */
    public static function getStatus($type = 1): array
    {
        $statusArr = self::$statusArr;
        foreach ($statusArr as $key => $value) {
            $statusArr[$key] = __('service.event_calendar.' . $value);
        }
        if ($type == 2) {
            unset($statusArr[1], $statusArr[2]);
        }
        return $statusArr;
    }

    /**
     * @param array $data
     * @param       $user_id
     * @return Builder|Model
     * @throws Exception
     */
    public function createModel(array $data, $user_id): Builder|Model
    {
        try {
            DB::beginTransaction();

            $start_time = get_datetime(
                'datetime',
                strtotime($data['start_time'])
            );
            $end_time = get_datetime('datetime', strtotime($data['end_time']));

            // 活动开始时间不能在已有活动时间内
            $this->validateTime($start_time);
            $this->validateTime($end_time);

            $model = EventCalendar::query()->create([
                'pattern_id'    => $data['pattern_id'],
                'start_time'    => $start_time,
                'end_time'      => $end_time,
                'admin_user_id' => $user_id,
                'status'        => 0,
                'created_at'    => get_datetime()
            ]);

            $this->logService->logCreated($model, 'event_calendar.create');

            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    // 验证时间是否在已有模式下存在
    protected function validateTime($start_time, $id = 0)
    {
        $model = EventCalendar::query();
        if ($id) {
            $model->where('id', '<>', $id);
        }
        $exists = $model->whereIn('status', [0, 1])
            ->where(function ($query) use ($start_time) {
                $query->whereRaw(
                    "'{$start_time}' BETWEEN start_time AND end_time"
                );
            })
            ->exists();
        if ($exists) {
            throw new Exception(
                __('service.event_calendar.pattern_exists')
            );
        }
    }

    /**
     * @param array  $data
     * @param string $id
     * @throws Exception
     */
    public function updateModel(array $data, string $id)
    {
        try {
            DB::beginTransaction();
            if (isset($data['status']) && $data['status'] == 0
                && isset($data['start_time'])
            ) {
                $start_time = get_datetime('datetime', strtotime($data['start_time']));
                $this->validateTime($start_time, $id);
            }
            $model = EventCalendar::query()->findOrFail($id);
            $oldValues = $model->toArray();

            $end_time = get_datetime('datetime', strtotime($data['end_time']));
            $this->validateTime($end_time, $id);

            $update = [
                'pattern_id'    => $data['pattern_id'],
                'end_time'      => $end_time,
                'admin_user_id' => $data['admin_user_id'],
                'updated_at'    => get_datetime()
            ];
            if ($oldValues['status'] == 0) {
                if (isset($data['start_time'])
                    && strtotime(
                        $data['start_time']
                    )
                ) {
                    $update['start_time'] = get_datetime(
                        'datetime',
                        strtotime($data['start_time'])
                    );
                }
            }
            if (isset($data['status']) && in_array($data['status'], [0, 3])) {
                $update['status'] = $data['status'];
            }

            $model->update($update);
            $this->logService->logUpdated(
                $model,
                $oldValues,
                'event_calendar.update'
            );

            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    public function deleteModel(int $id): bool
    {
        try {
            DB::beginTransaction();

            $model = EventCalendar::query()->findOrFail($id);
            if ($model['status'] == 1) {
                throw new Exception(__('service.event_calendar.error_status'));
            }

            $this->logService->logDeleted($model, 'event_calendar.delete');

            $model->delete();

            DB::commit();
            return true;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    public function endModel(int $id, $user_id): bool
    {
        try {
            DB::beginTransaction();
            $model = EventCalendar::query()->findOrFail($id);
            $oldValues = $model->toArray();
            if ($model['status'] != 1) {
                throw new Exception(__('service.event_calendar.error_end'));
            }
            $update = [
                'status' => 2,
                'admin_user_id' => $user_id,
                'updated_at' => get_datetime()
            ];
            $model->update($update);
            $this->logService->logUpdated(
                $model,
                $oldValues,
                'event_calendar.update'
            );

            // 切换回默认模式 或者 需要运行的模式
            $this->autoChangeMode($user_id);
            DB::commit();
            return true;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    public function changeModel($data, $user_id)
    {
        try {
            DB::beginTransaction();
            $pattern_id = $data['pattern_id'];
            $exists = ParkingPatternSpace::getParkingSpaceIds($pattern_id);
            if (!$exists) {
                throw new Exception('service.event_calendar.not_space');
            }
            $end_time = $data['end_time'];

            // 将其他模式未结束，在运行中的全部结束
            $nowWhere = [
                ['status', '=', 1],
                ['pattern_id', '<>', $pattern_id]
            ];
            $nowQuery = EventCalendar::query()->where($nowWhere)->first();
            if ($nowQuery) {
                $model = EventCalendar::query()->findOrFail($nowQuery['id']);
                $nowSave = [
                    'status' => 2,
                    'updated_at' => get_datetime(),
                    'admin_user_id' => $user_id
                ];
                $oldValues = $model->toArray();
                // 小于还未到结束时间，自动跳转计划中
                if ($oldValues['end_time']) {
                    if (time() < strtotime($oldValues['end_time'])) {
                        $nowSave['status'] = 0;
                    }
                }
                $model->update($nowSave);
                $this->logService->logUpdated(
                    $model,
                    $oldValues,
                    'event_calendar.update'
                );
            }
            $now_time = date("Y-m-d H:i:s", time());
            $query = EventCalendar::query()->where('pattern_id', $pattern_id)
                ->whereIn('status', [0, 1])
                ->where(function ($query) use ($now_time) {
                    $query->whereRaw(
                        "'{$now_time}' BETWEEN start_time AND end_time"
                    );
                })
                ->first();

            $end_time = get_datetime('datetime', strtotime($end_time));
            $save = [
                'pattern_id'    => $pattern_id,
                'end_time'      => $end_time,
                'status'        => 1,
                'admin_user_id' => $user_id,
                'is_manual'     => 1
            ];

            if ($query) {
                $save['updated_at'] = get_datetime();
                $model = EventCalendar::query()->findOrFail($query['id']);
                $oldValues = $model->toArray();
                $model->update($save);
                $this->logService->logUpdated(
                    $model,
                    $oldValues,
                    'event_calendar.update'
                );
            } else {
                $save['start_time'] = get_datetime();
                $save['created_at'] = get_datetime();
                $model = EventCalendar::query()->create($save);
                $this->logService->logCreated($model, 'event_calendar.create');
            }

            // 切换活动模式，将模式所有车位类型 全部更新当前车位
            $this->syncUpdateSpaceType($pattern_id);
            // 生成警报信息消息
            AdminNoticeService::addChangeModeNotice($pattern_id, $user_id);

            DB::commit();
            return $model;
        } catch (Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    // 返回当前模式的模式信息
    public static function targetModel()
    {
        $pattern_id = EventCalendar::query()->where('status', 1)->value('pattern_id');
        $columns = ['id as pattern_id', 'name as model_name'];
        if ($pattern_id) {
            $data = ParkingPattern::query()->find($pattern_id, $columns)->toArray();
        } else {
            $data = ParkingPattern::query()->where('is_default', 1)->first($columns);
        }
        if (isset($data['model_name'])) {
            $data['model_name']
                = AdminTranslationService::getTranslationTypeName(
                $data['pattern_id'],
                10,
                $data['model_name']
            );
        }
        return $data;
    }

    // 返回当前模式的模式id
    public static function getTargetModeId()
    {
        $data = self::targetModel();
        return $data['pattern_id'] ?? '';
    }

    // 切换模式后 - 同步更新所有车位类型
    public function syncUpdateSpaceType($pattern_id)
    {
        // 查询当前模式是否
        $data = ParkingPatternSpace::query()->where('pattern_id', $pattern_id)
            ->select()
            ->get()->toArray();
        foreach ($data as $item) {
            $space_id = $item['space_id'];
            $space_type_id = $item['space_type_id'];
            (new ParkingSpaceService(
                $this->logService
            ))->syncUpdateSpaceData(
                $space_id,
                $space_type_id,
                $pattern_id,
                false
            );
        }
    }

    // 自动切换模式
    public function autoChangeMode($user_id)
    {
        $now_time = date("Y-m-d H:i:s", time());
        $where = [
            ['status', '=', 0]
        ];
        $res = EventCalendar::query()->where($where)->where(function ($query) use ($now_time) {
            $query->whereRaw(
                "'{$now_time}' BETWEEN start_time AND end_time"
            );
        })->orderBy('start_time')
            ->first(['id']);
        if ($res) {
            $this->updateStatus($res['id'], $user_id,1, true);
        } else {
            // 如果不存在新活动模式，撤回默认模式
            $pattern_id = EventCalendarService::getTargetModeId();
            if ($pattern_id) {
                // 更新车位类型
                $this->syncUpdateSpaceType($pattern_id);
                // 记录日志
                AdminNoticeService::addChangeModeNotice($pattern_id, $user_id);
            }
        }
    }

    /**
     * 切换模式 更改状态
     * @param      $id
     * @param      $user_id
     * @param int  $status // 1运行 、 2结束
     * @param bool $is_notice
     * @return void
     */
    public function updateStatus(
        $id,
        $user_id,
        int $status = 1,
        bool $is_notice = false
    ): void {
        $model = EventCalendar::query()->findOrFail($id);
        $oldValue = $model->toArray();
        $model->update([
            'status'        => $status,
            'admin_user_id' => $user_id,
            'updated_at'    => date("Y-m-d H:i:s", time())
        ]);
        // 记录日志
        $this->logService->logUpdated(
            $model,
            $oldValue,
            'event_calendar.update'
        );
        // 记录警报信息, 切换任务, 同步更新指定模式车位类型
        if ($is_notice) {
            $pattern_id = $oldValue['pattern_id'];
            // 更新车位类型
            $this->syncUpdateSpaceType($pattern_id);
            // 记录日志
            AdminNoticeService::addChangeModeNotice($pattern_id, $user_id);
        }
    }
}