package com.vincent.rsf.server.manager.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.MatnrPrintTemplate;
import com.vincent.rsf.server.manager.mapper.MatnrPrintTemplateMapper;
import com.vincent.rsf.server.manager.service.MatnrPrintTemplateService;
import com.vincent.rsf.server.system.entity.User;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

@Service("matnrPrintTemplateService")
public class MatnrPrintTemplateServiceImpl
        extends ServiceImpl<MatnrPrintTemplateMapper, MatnrPrintTemplate>
        implements MatnrPrintTemplateService {

    private static final Set<String> SUPPORTED_ELEMENT_TYPES = Collections.unmodifiableSet(
            new LinkedHashSet<>(Arrays.asList("text", "barcode", "qrcode", "line", "rect", "table"))
    );

    @Override
    public List<MatnrPrintTemplate> listCurrentTenantTemplates() {
        List<MatnrPrintTemplate> templates = this.list(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .orderByDesc(MatnrPrintTemplate::getIsDefault)
                .orderByDesc(MatnrPrintTemplate::getUpdateTime)
                .orderByDesc(MatnrPrintTemplate::getCreateTime)
        );
        return templates == null ? new ArrayList<>() : templates;
    }

    @Override
    public MatnrPrintTemplate getCurrentTenantTemplate(Long id) {
        if (id == null) {
            throw new CoolException("模板ID不能为空");
        }
        MatnrPrintTemplate template = this.getById(id);
        if (template == null) {
            throw new CoolException("模板不存在或已被删除");
        }
        return template;
    }

    @Override
    public MatnrPrintTemplate getCurrentTenantDefaultTemplate() {
        MatnrPrintTemplate template = this.getOne(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getStatus, 1)
                .eq(MatnrPrintTemplate::getIsDefault, 1)
                .orderByDesc(MatnrPrintTemplate::getUpdateTime)
                .last("limit 1")
        );
        if (template != null) {
            return template;
        }
        return this.getOne(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getStatus, 1)
                .orderByDesc(MatnrPrintTemplate::getUpdateTime)
                .orderByDesc(MatnrPrintTemplate::getCreateTime)
                .last("limit 1")
        );
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MatnrPrintTemplate saveTemplate(MatnrPrintTemplate template) {
        MatnrPrintTemplate normalized = prepareTemplateForSave(template, false);
        long currentCount = this.count();
        boolean shouldDefault = Objects.equals(normalized.getIsDefault(), 1) || currentCount == 0;
        normalized.setIsDefault(shouldDefault ? 1 : 0);
        if (shouldDefault) {
            clearCurrentTenantDefaults();
        }
        if (!this.save(normalized)) {
            throw new CoolException("模板保存失败");
        }
        return this.getCurrentTenantTemplate(normalized.getId());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public MatnrPrintTemplate updateTemplate(MatnrPrintTemplate template) {
        if (template == null || template.getId() == null) {
            throw new CoolException("模板ID不能为空");
        }
        MatnrPrintTemplate existing = getCurrentTenantTemplate(template.getId());
        MatnrPrintTemplate normalized = prepareTemplateForSave(template, true);
        normalized.setTenantId(existing.getTenantId());
        normalized.setCreateBy(existing.getCreateBy());
        normalized.setCreateTime(existing.getCreateTime());
        normalized.setDeleted(existing.getDeleted());
        boolean shouldDefault = Objects.equals(normalized.getIsDefault(), 1);
        if (shouldDefault) {
            clearCurrentTenantDefaults();
        } else if (Objects.equals(existing.getIsDefault(), 1)) {
            normalized.setIsDefault(1);
        }
        if (!this.updateById(normalized)) {
            throw new CoolException("模板更新失败");
        }
        ensureOneDefaultTemplate();
        return this.getCurrentTenantTemplate(normalized.getId());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeTemplates(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new CoolException("请选择要删除的模板");
        }
        List<MatnrPrintTemplate> templates = this.listByIds(ids);
        if (templates == null || templates.isEmpty()) {
            return true;
        }
        boolean removedDefault = templates.stream().anyMatch(item -> Objects.equals(item.getIsDefault(), 1));
        if (!this.removeByIds(ids)) {
            throw new CoolException("模板删除失败");
        }
        if (removedDefault) {
            ensureOneDefaultTemplate();
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean setDefaultTemplate(Long id) {
        MatnrPrintTemplate template = getCurrentTenantTemplate(id);
        clearCurrentTenantDefaults();
        boolean updated = this.update(new LambdaUpdateWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getId, template.getId())
                .set(MatnrPrintTemplate::getIsDefault, 1)
                .set(MatnrPrintTemplate::getUpdateBy, resolveCurrentUserId())
                .set(MatnrPrintTemplate::getUpdateTime, new Date())
        );
        if (!updated) {
            throw new CoolException("默认模板设置失败");
        }
        return true;
    }

    private MatnrPrintTemplate prepareTemplateForSave(MatnrPrintTemplate template, boolean updating) {
        if (template == null) {
            throw new CoolException("模板参数不能为空");
        }
        Long currentTenantId = resolveCurrentTenantId();
        Long currentUserId = resolveCurrentUserId();
        if (currentTenantId == null) {
            throw new CoolException("当前租户信息缺失");
        }
        String name = normalizeText(template.getName());
        String code = normalizeText(template.getCode());
        if (name.isEmpty()) {
            throw new CoolException("模板名称不能为空");
        }
        if (code.isEmpty()) {
            throw new CoolException("模板编码不能为空");
        }
        Map<String, Object> canvasJson = template.getCanvasJson();
        if (canvasJson == null || canvasJson.isEmpty()) {
            throw new CoolException("模板画布不能为空");
        }
        validateCanvasJson(canvasJson);
        ensureTemplateCodeUnique(code, updating ? template.getId() : null);

        Date now = new Date();
        template.setTenantId(currentTenantId)
                .setName(name)
                .setCode(code)
                .setStatus(template.getStatus() == null ? 1 : template.getStatus())
                .setIsDefault(Objects.equals(template.getIsDefault(), 1) ? 1 : 0)
                .setMemo(normalizeText(template.getMemo()))
                .setUpdateBy(currentUserId)
                .setUpdateTime(now);
        if (!updating) {
            template.setCreateBy(currentUserId);
            template.setCreateTime(now);
        }
        return template;
    }

    private void ensureTemplateCodeUnique(String code, Long excludeId) {
        long duplicateCount = this.count(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getCode, code)
                .ne(excludeId != null, MatnrPrintTemplate::getId, excludeId)
        );
        if (duplicateCount > 0) {
            throw new CoolException("模板编码已存在，请更换后重试");
        }
    }

    private void clearCurrentTenantDefaults() {
        this.update(new LambdaUpdateWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getIsDefault, 1)
                .set(MatnrPrintTemplate::getIsDefault, 0)
                .set(MatnrPrintTemplate::getUpdateBy, resolveCurrentUserId())
                .set(MatnrPrintTemplate::getUpdateTime, new Date())
        );
    }

    private void ensureOneDefaultTemplate() {
        long defaultCount = this.count(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getIsDefault, 1)
        );
        if (defaultCount > 0) {
            return;
        }
        MatnrPrintTemplate newest = this.getOne(new LambdaQueryWrapper<MatnrPrintTemplate>()
                .orderByDesc(MatnrPrintTemplate::getUpdateTime)
                .orderByDesc(MatnrPrintTemplate::getCreateTime)
                .last("limit 1")
        );
        if (newest == null) {
            return;
        }
        this.update(new LambdaUpdateWrapper<MatnrPrintTemplate>()
                .eq(MatnrPrintTemplate::getId, newest.getId())
                .set(MatnrPrintTemplate::getIsDefault, 1)
                .set(MatnrPrintTemplate::getUpdateBy, resolveCurrentUserId())
                .set(MatnrPrintTemplate::getUpdateTime, new Date())
        );
    }

    private void validateCanvasJson(Map<String, Object> canvasJson) {
        JSONObject root = JSONObject.parseObject(JSON.toJSONString(canvasJson));
        if (root == null) {
            throw new CoolException("模板画布格式不正确");
        }
        if (root.getInteger("version") == null) {
            throw new CoolException("模板版本不能为空");
        }
        JSONObject canvas = root.getJSONObject("canvas");
        if (canvas == null) {
            throw new CoolException("模板画布配置不能为空");
        }
        double width = getPositiveNumber(canvas, "width", "画布宽度");
        double height = getPositiveNumber(canvas, "height", "画布高度");
        if (width <= 0 || height <= 0) {
            throw new CoolException("画布尺寸必须大于0");
        }
        String unit = normalizeText(canvas.getString("unit"));
        if (!"mm".equals(unit)) {
            throw new CoolException("画布单位仅支持 mm");
        }
        JSONArray elements = root.getJSONArray("elements");
        if (elements == null) {
            throw new CoolException("模板元素不能为空");
        }
        for (int index = 0; index < elements.size(); index++) {
            JSONObject element = elements.getJSONObject(index);
            if (element == null) {
                throw new CoolException("模板元素格式不正确");
            }
            validateElement(element, index);
        }
    }

    private void validateElement(JSONObject element, int index) {
        String type = normalizeText(element.getString("type"));
        if (!SUPPORTED_ELEMENT_TYPES.contains(type)) {
            throw new CoolException("第" + (index + 1) + "个元素类型不支持");
        }
        if (normalizeText(element.getString("id")).isEmpty()) {
            throw new CoolException("第" + (index + 1) + "个元素缺少 ID");
        }
        ensureNumber(element, "x", "元素 X 坐标");
        ensureNumber(element, "y", "元素 Y 坐标");
        if (!"line".equals(type)) {
            getPositiveNumber(element, "w", "元素宽度");
            getPositiveNumber(element, "h", "元素高度");
        } else {
            String direction = normalizeText(element.getString("direction"));
            if (!Arrays.asList("horizontal", "vertical").contains(direction)) {
                throw new CoolException("线条元素方向仅支持 horizontal 或 vertical");
            }
            getPositiveNumber(element, "w", "线条长度");
            getPositiveNumber(element, "h", "线条粗细");
        }

        switch (type) {
            case "text":
                String contentMode = normalizeText(element.getString("contentMode"));
                if (!Arrays.asList("static", "template").contains(contentMode)) {
                    throw new CoolException("文本元素内容模式不支持");
                }
                if (normalizeText(element.getString("contentTemplate")).isEmpty()) {
                    throw new CoolException("文本元素内容不能为空");
                }
                break;
            case "barcode":
                if (normalizeText(element.getString("valueTemplate")).isEmpty()) {
                    throw new CoolException("条码元素值模板不能为空");
                }
                String symbology = normalizeText(element.getString("symbology"));
                if (!symbology.isEmpty() && !"CODE128".equals(symbology)) {
                    throw new CoolException("一维码仅支持 CODE128");
                }
                break;
            case "qrcode":
                if (normalizeText(element.getString("valueTemplate")).isEmpty()) {
                    throw new CoolException("二维码元素值模板不能为空");
                }
                break;
            case "table":
                if (element.getJSONArray("columns") == null) {
                    throw new CoolException("表格元素 columns 不能为空");
                }
                if (element.getJSONArray("rows") == null) {
                    throw new CoolException("表格元素 rows 不能为空");
                }
                if (element.getJSONArray("cells") == null) {
                    throw new CoolException("表格元素 cells 不能为空");
                }
                break;
            default:
                break;
        }
    }

    private void ensureNumber(JSONObject object, String key, String label) {
        if (object.getBigDecimal(key) == null) {
            throw new CoolException(label + "不能为空");
        }
    }

    private double getPositiveNumber(JSONObject object, String key, String label) {
        if (object.getBigDecimal(key) == null) {
            throw new CoolException(label + "不能为空");
        }
        double value = object.getBigDecimal(key).doubleValue();
        if (value <= 0) {
            throw new CoolException(label + "必须大于0");
        }
        return value;
    }

    private String normalizeText(String value) {
        return value == null ? "" : value.trim();
    }

    private Long resolveCurrentTenantId() {
        User loginUser = getCurrentUser();
        return loginUser == null ? null : loginUser.getTenantId();
    }

    private Long resolveCurrentUserId() {
        User loginUser = getCurrentUser();
        return loginUser == null ? null : loginUser.getId();
    }

    private User getCurrentUser() {
        try {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            if (authentication != null && authentication.getPrincipal() instanceof User) {
                return (User) authentication.getPrincipal();
            }
        } catch (Exception ignored) {
        }
        return null;
    }
}