package com.tcm.training.admin.live.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tcm.training.admin.common.PageResponse;
import com.tcm.training.admin.live.dto.LiveCourseCategorySaveRequest;
import com.tcm.training.admin.live.entity.LiveCourseCategory;
import com.tcm.training.admin.live.mapper.LiveCourseCategoryMapper;
import com.tcm.training.admin.live.vo.LiveCourseCategoryDetailVO;
import com.tcm.training.admin.live.vo.LiveCourseCategoryItemVO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

@Service
public class LiveCourseCategoryAppService {

    public static final String TYPE_LEVEL = "LEVEL";
    public static final String TYPE_DIFFICULTY = "DIFFICULTY";

    private final LiveCourseCategoryMapper liveCourseCategoryMapper;

    public LiveCourseCategoryAppService(LiveCourseCategoryMapper liveCourseCategoryMapper) {
        this.liveCourseCategoryMapper = liveCourseCategoryMapper;
    }

    public PageResponse<LiveCourseCategoryItemVO> page(int page, int pageSize, String type) {
        String normalizedType = normalizeType(type);
        LambdaQueryWrapper<LiveCourseCategory> qw = new LambdaQueryWrapper<LiveCourseCategory>()
                .eq(LiveCourseCategory::getType, normalizedType)
                .orderByAsc(LiveCourseCategory::getSort)
                .orderByAsc(LiveCourseCategory::getId);
        IPage<LiveCourseCategory> p = liveCourseCategoryMapper.selectPage(new Page<LiveCourseCategory>(page, pageSize), qw);
        List<LiveCourseCategoryItemVO> list = new ArrayList<LiveCourseCategoryItemVO>();
        for (LiveCourseCategory item : p.getRecords()) {
            list.add(new LiveCourseCategoryItemVO(
                    item.getId(),
                    item.getType(),
                    item.getName(),
                    item.getSort(),
                    item.getCreatedAt()
            ));
        }
        return PageResponse.of(list, p.getTotal(), p.getCurrent(), p.getSize());
    }

    public LiveCourseCategoryDetailVO detail(Long id) {
        return toDetailVO(requireCategory(id));
    }

    @Transactional
    public LiveCourseCategoryDetailVO create(String type, LiveCourseCategorySaveRequest req) {
        String normalizedType = normalizeType(type);
        String name = normalizeName(req.getName());
        validateUniqueName(normalizedType, name, null);

        LiveCourseCategory entity = new LiveCourseCategory();
        entity.setType(normalizedType);
        entity.setName(name);
        entity.setSort(resolveSort(req.getSort()));
        entity.setDeleted(0);
        liveCourseCategoryMapper.insert(entity);
        return detail(entity.getId());
    }

    @Transactional
    public LiveCourseCategoryDetailVO update(Long id, LiveCourseCategorySaveRequest req) {
        LiveCourseCategory entity = requireCategory(id);
        String name = normalizeName(req.getName());
        validateUniqueName(entity.getType(), name, id);

        entity.setName(name);
        entity.setSort(resolveSort(req.getSort()));
        liveCourseCategoryMapper.updateById(entity);
        return detail(id);
    }

    @Transactional
    public void delete(Long id) {
        requireCategory(id);
        liveCourseCategoryMapper.deleteById(id);
    }

    private LiveCourseCategory requireCategory(Long id) {
        LiveCourseCategory entity = liveCourseCategoryMapper.selectOne(new LambdaQueryWrapper<LiveCourseCategory>()
                .eq(LiveCourseCategory::getId, id)
                .eq(LiveCourseCategory::getDeleted, 0)
                .last("limit 1"));
        if (entity == null) {
            throw new IllegalArgumentException("分类不存在");
        }
        return entity;
    }

    private void validateUniqueName(String type, String name, Long excludeId) {
        LambdaQueryWrapper<LiveCourseCategory> qw = new LambdaQueryWrapper<LiveCourseCategory>()
                .eq(LiveCourseCategory::getType, type)
                .eq(LiveCourseCategory::getName, name)
                .eq(LiveCourseCategory::getDeleted, 0);
        if (excludeId != null) {
            qw.ne(LiveCourseCategory::getId, excludeId);
        }
        Long count = liveCourseCategoryMapper.selectCount(qw);
        if (count != null && count > 0) {
            throw new IllegalArgumentException(resolveLabel(type) + "名称已存在");
        }
    }

    private String normalizeType(String type) {
        if (type == null) {
            throw new IllegalArgumentException("分类类型不能为空");
        }
        String normalized = type.trim().toUpperCase();
        if (!TYPE_LEVEL.equals(normalized) && !TYPE_DIFFICULTY.equals(normalized)) {
            throw new IllegalArgumentException("分类类型不合法");
        }
        return normalized;
    }

    private String normalizeName(String name) {
        String normalized = name == null ? "" : name.trim();
        if (normalized.isEmpty()) {
            throw new IllegalArgumentException("请输入分类名称");
        }
        return normalized;
    }

    private Integer resolveSort(Integer sort) {
        return sort == null ? 0 : sort;
    }

    private String resolveLabel(String type) {
        return TYPE_LEVEL.equals(type) ? "养身等级" : "难度";
    }

    private LiveCourseCategoryDetailVO toDetailVO(LiveCourseCategory entity) {
        LiveCourseCategoryDetailVO vo = new LiveCourseCategoryDetailVO();
        vo.setId(entity.getId());
        vo.setType(entity.getType());
        vo.setName(entity.getName());
        vo.setSort(entity.getSort());
        vo.setCreatedAt(entity.getCreatedAt());
        vo.setUpdatedAt(entity.getUpdatedAt());
        return vo;
    }
}