<?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']));

            // 活动开始时间不能在已有活动时间内
            $exists = EventCalendar::query()->whereIn('status', [0, 1])->where(
                'pattern_id',
                $data['pattern_id']
            )
                ->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')
                );
            }

            $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;
        }
    }

    /**
     * @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 = $data['start_time'];
                $existsWhere = [
                    ['pattern_id', '=', $data['pattern_id']],
                    ['id', '<>', $id]
                ];
                if (EventCalendar::query()->where($existsWhere)->whereIn(
                    'status',
                    [0, 1]
                )
                    ->where(function ($query) use ($start_time) {
                        $query->whereRaw(
                            "'{$start_time}' BETWEEN start_time AND end_time"
                        );
                    })->exists()
                ) {
                    throw new Exception(
                        __('service.event_calendar.pattern_exists')
                    );
                }
            }
            $model = EventCalendar::query()->findOrFail($id);
            $oldValues = $model->toArray();

            $end_time = get_datetime('datetime', strtotime($data['end_time']));
            $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'
            );

            // 切换回默认模式
            $pattern_id = EventCalendarService::getTargetModeId();
            if ($pattern_id) {
                // 更新车位类型
                $this->syncUpdateSpaceType($pattern_id);
                // 记录日志
                AdminNoticeService::addChangeModeNotice($pattern_id, $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'
                );
            }

            $query = EventCalendar::query()->where('pattern_id', $pattern_id)
                ->whereIn('status', [0, 1])->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);
        }
        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
            );
        }
    }
}