package jnpf.bizcommon.onlyoffice.service.impl;

import cn.hutool.core.util.IdUtil;
import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeProperties;
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeSessionEntity;
import jnpf.bizcommon.onlyoffice.mapper.OnlyOfficeSessionMapper;
import jnpf.exception.DataException;
import lombok.RequiredArgsConstructor;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.Date;
import java.util.UUID;

/** 在 OnlyOffice 会话状态机内为 ELN 记录修订提供互斥 fence。 */
@Service
@RequiredArgsConstructor
public class OnlyOfficeRecordRevisionFenceService {

    static final String ELN_RECORD_BIZ_MODULE = "eln.record";
    private static final String FREEZE_TOKEN_PREFIX = "freeze:";
    private static final String CANCELLED_TOKEN_PREFIX = "cancelled:";

    private final OnlyOfficeSessionMapper sessionMapper;
    private final OnlyOfficeFreezeCancellationStore cancellationStore;
    private final OnlyOfficeProperties properties;

    public String acquire(String tenantId, String recordId, String fileId, String fileType) {
        return acquireWithToken(tenantId, recordId, fileId, fileType,
                UUID.randomUUID().toString(), false);
    }

    public String acquireForOperation(String tenantId, String recordId, String fileId,
                                      String fileType, String operationCode) {
        requireIdentity(tenantId, recordId, fileId, fileType);
        if (!StringUtils.hasText(operationCode)) throw new DataException("记录冻结操作码不能为空");
        String token = FREEZE_TOKEN_PREFIX + operationCode.trim();
        rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
        return acquireWithToken(tenantId, recordId, fileId, fileType, token, true);
    }

    private String acquireWithToken(String tenantId, String recordId, String fileId,
                                    String fileType, String token, boolean idempotent) {
        requireIdentity(tenantId, recordId, fileId, fileType);
        OnlyOfficeSessionEntity existing = find(tenantId, fileId, fileType);
        if (idempotent && isCancelled(existing, recordId, token)) throw cancelled();
        if (idempotent && ownsFence(existing, recordId, token)) return token;
        if (existing != null) {
            if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
            acquireExisting(existing, tenantId, recordId, fileId, fileType, token);
            if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
            return token;
        }

        if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
        OnlyOfficeSessionEntity placeholder = placeholder(tenantId, recordId, fileId,
                fileType, OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING, token);
        try {
            if (sessionMapper.insert(placeholder) == 1) {
                if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
                return token;
            }
        } catch (DuplicateKeyException ignored) {
            // 编辑器首次打开或同操作并发插入时，由文件唯一键裁决后重读。
        }

        existing = find(tenantId, fileId, fileType);
        if (idempotent && isCancelled(existing, recordId, token)) throw cancelled();
        if (idempotent && ownsFence(existing, recordId, token)) return token;
        if (existing == null) throw busy();
        if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
        acquireExisting(existing, tenantId, recordId, fileId, fileType, token);
        if (idempotent) rejectIfCancelled(tenantId, recordId, fileId, fileType, token);
        return token;
    }

    private void rejectIfCancelled(String tenantId, String recordId, String fileId,
                                   String fileType, String token) {
        boolean cancelled;
        try {
            cancelled = cancellationStore.isCancelled(tenantId, recordId, fileId, fileType, token);
        } catch (RuntimeException e) {
            cancelOrReleaseOperation(tenantId, recordId, fileId, fileType, token);
            throw e;
        }
        if (!cancelled) return;
        cancelOrReleaseOperation(tenantId, recordId, fileId, fileType, token);
        throw cancelled();
    }

    private static OnlyOfficeSessionEntity placeholder(String tenantId, String recordId,
                                                       String fileId, String fileType,
                                                       int status, String token) {
        OnlyOfficeSessionEntity placeholder = new OnlyOfficeSessionEntity();
        placeholder.setId(IdUtil.getSnowflakeNextIdStr());
        placeholder.setTenantId(tenantId);
        placeholder.setFileId(fileId);
        placeholder.setFileType(fileType);
        placeholder.setFileName(fileId);
        placeholder.setDocumentType("word");
        placeholder.setBizModule(ELN_RECORD_BIZ_MODULE);
        placeholder.setBizDataId(recordId);
        placeholder.setVersionNo(1);
        placeholder.setVersion(1);
        placeholder.setSessionStatus(status);
        placeholder.setPublishToken(token);
        placeholder.setDocKey(DigestUtil.md5Hex(fileId + "_1"));
        return placeholder;
    }

    private static boolean ownsFence(OnlyOfficeSessionEntity existing,
                                     String recordId, String token) {
        return existing != null && ELN_RECORD_BIZ_MODULE.equals(existing.getBizModule())
                && recordId.equals(existing.getBizDataId())
                && Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING)
                .equals(existing.getSessionStatus())
                && token.equals(existing.getPublishToken());
    }

    private static boolean isCancelled(OnlyOfficeSessionEntity existing,
                                       String recordId, String token) {
        return existing != null && ELN_RECORD_BIZ_MODULE.equals(existing.getBizModule())
                && recordId.equals(existing.getBizDataId())
                && Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.IDLE)
                .equals(existing.getSessionStatus())
                && (CANCELLED_TOKEN_PREFIX + token).equals(existing.getPublishToken());
    }

    public boolean complete(String tenantId, String recordId, String fileId,
                            String fileType, String token) {
        return finish(tenantId, recordId, fileId, fileType, token,
                OnlyOfficeSessionEntity.SessionStatus.RECORD_HISTORICAL);
    }

    public boolean release(String tenantId, String recordId, String fileId,
                           String fileType, String token) {
        if (StringUtils.hasText(token) && token.startsWith(FREEZE_TOKEN_PREFIX)) {
            cancellationStore.cancel(tenantId, recordId, fileId, fileType, token);
            return cancelOrReleaseOperation(tenantId, recordId, fileId, fileType, token);
        }
        return finish(tenantId, recordId, fileId, fileType, token,
                OnlyOfficeSessionEntity.SessionStatus.IDLE);
    }

    public boolean releaseAfterDocumentUpdate(
            String tenantId, String recordId, String fileId,
            String fileType, String token) {
        requireIdentity(tenantId, recordId, fileId, fileType);
        if (!StringUtils.hasText(token)) {
            throw new DataException("记录修订 fence token 不能为空");
        }
        OnlyOfficeSessionEntity existing = find(tenantId, fileId, fileType);
        if (!ownsFence(existing, recordId, token)) return false;
        int nextVersionNo = existing.getVersionNo() == null
                ? 1 : existing.getVersionNo() + 1;
        int nextVersion = existing.getVersion() == null
                ? 1 : existing.getVersion() + 1;
        UpdateWrapper<OnlyOfficeSessionEntity> update = identityUpdate(
                tenantId, recordId, fileId, fileType)
                .eq("f_id", existing.getId())
                .eq("session_status", OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING)
                .eq("publish_token", token)
                .set("session_status", OnlyOfficeSessionEntity.SessionStatus.IDLE)
                .set("publish_token", null)
                .set("lock_user_id", null)
                .set("lock_heartbeat", null)
                .set("last_save_time", new Date())
                .set("version_no", nextVersionNo)
                .set("doc_key", DigestUtil.md5Hex(fileId + "_" + nextVersionNo))
                .set("f_version", nextVersion);
        if (existing.getVersionNo() == null) {
            update.isNull("version_no");
        } else {
            update.eq("version_no", existing.getVersionNo());
        }
        if (existing.getVersion() == null) {
            update.isNull("f_version");
        } else {
            update.eq("f_version", existing.getVersion());
        }
        return sessionMapper.update(null, update) == 1;
    }

    private boolean cancelOrReleaseOperation(String tenantId, String recordId, String fileId,
                                             String fileType, String token) {
        if (finish(tenantId, recordId, fileId, fileType, token,
                OnlyOfficeSessionEntity.SessionStatus.IDLE)) return true;
        String cancelledToken = CANCELLED_TOKEN_PREFIX + token;
        for (int attempt = 0; attempt < 3; attempt++) {
            OnlyOfficeSessionEntity existing = find(tenantId, fileId, fileType);
            if (isCancelled(existing, recordId, token)) return true;
            if (ownsFence(existing, recordId, token)) {
                if (finish(tenantId, recordId, fileId, fileType, token,
                        OnlyOfficeSessionEntity.SessionStatus.IDLE)) return true;
                continue;
            }
            if (existing == null) {
                try {
                    if (sessionMapper.insert(placeholder(tenantId, recordId, fileId, fileType,
                            OnlyOfficeSessionEntity.SessionStatus.IDLE, cancelledToken)) == 1) return true;
                } catch (DuplicateKeyException ignored) {
                    // 与 acquireForOperation 并发插入时重读，由文件唯一键裁决。
                }
                continue;
            }
            if (!ELN_RECORD_BIZ_MODULE.equals(existing.getBizModule())
                    || !recordId.equals(existing.getBizDataId())
                    || !Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.IDLE)
                    .equals(existing.getSessionStatus())) {
                // 当前非空闲状态会使同操作的 acquire CAS 失败，不会遗留本操作 fence。
                return true;
            }
            if (transitionIdle(existing, tenantId, recordId, fileId, fileType,
                    OnlyOfficeSessionEntity.SessionStatus.IDLE, cancelledToken)) return true;
        }
        return false;
    }

    private boolean finish(String tenantId, String recordId, String fileId,
                           String fileType, String token, int targetStatus) {
        requireIdentity(tenantId, recordId, fileId, fileType);
        if (!StringUtils.hasText(token)) {
            throw new DataException("记录修订 fence token 不能为空");
        }
        return sessionMapper.update(null, identityUpdate(
                tenantId, recordId, fileId, fileType)
                .eq("session_status", OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING)
                .eq("publish_token", token)
                .set("session_status", targetStatus)
                .set("publish_token", null)
                .set("lock_user_id", null)
                .set("lock_heartbeat", null)) == 1;
    }

    private void acquireExisting(OnlyOfficeSessionEntity existing, String tenantId,
                                 String recordId, String fileId, String fileType,
                                 String token) {
        if (!ELN_RECORD_BIZ_MODULE.equals(existing.getBizModule())
                || !recordId.equals(existing.getBizDataId()) || !isAvailable(existing)) {
            throw busy();
        }
        if (!transitionAvailable(existing, tenantId, recordId, fileId, fileType,
                OnlyOfficeSessionEntity.SessionStatus.RECORD_RETIRING, token)) throw busy();
    }

    private boolean isAvailable(OnlyOfficeSessionEntity existing) {
        if (Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.IDLE)
                .equals(existing.getSessionStatus())) return true;
        if (!Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.EDITING)
                .equals(existing.getSessionStatus())) return false;
        if (!StringUtils.hasText(existing.getLockUserId()) || existing.getLockHeartbeat() == null) return true;
        long timeoutMillis = properties.getLockTimeoutMinutes() * 60L * 1000L;
        return System.currentTimeMillis() - existing.getLockHeartbeat().getTime() >= timeoutMillis;
    }

    private boolean transitionAvailable(OnlyOfficeSessionEntity existing, String tenantId,
                                        String recordId, String fileId, String fileType,
                                        int targetStatus, String token) {
        int nextVersion = existing.getVersion() == null ? 1 : existing.getVersion() + 1;
        java.util.Date expiredBefore = new java.util.Date(System.currentTimeMillis()
                - properties.getLockTimeoutMinutes() * 60L * 1000L);
        UpdateWrapper<OnlyOfficeSessionEntity> update = identityUpdate(tenantId, recordId, fileId, fileType)
                .eq("f_id", existing.getId()).eq("doc_key", existing.getDocKey())
                .eq("version_no", existing.getVersionNo())
                .and(available -> available.eq("session_status", OnlyOfficeSessionEntity.SessionStatus.IDLE)
                        .or(editing -> editing
                                .eq("session_status", OnlyOfficeSessionEntity.SessionStatus.EDITING)
                                .and(expired -> expired.isNull("lock_user_id").or().eq("lock_user_id", "")
                                        .or().isNull("lock_heartbeat").or().lt("lock_heartbeat", expiredBefore))))
                .set("session_status", targetStatus).set("publish_token", token)
                .set("lock_user_id", null).set("lock_heartbeat", null)
                .set("f_version", nextVersion);
        if (existing.getVersion() == null) {
            update.isNull("f_version");
        } else {
            update.eq("f_version", existing.getVersion());
        }
        return sessionMapper.update(null, update) == 1;
    }

    private boolean transitionIdle(OnlyOfficeSessionEntity existing, String tenantId,
                                   String recordId, String fileId, String fileType,
                                   int targetStatus, String token) {
        int nextVersion = existing.getVersion() == null ? 1 : existing.getVersion() + 1;
        UpdateWrapper<OnlyOfficeSessionEntity> update = identityUpdate(tenantId, recordId, fileId, fileType)
                .eq("f_id", existing.getId()).eq("doc_key", existing.getDocKey())
                .eq("version_no", existing.getVersionNo())
                .eq("session_status", OnlyOfficeSessionEntity.SessionStatus.IDLE)
                .set("session_status", targetStatus).set("publish_token", token)
                .set("lock_user_id", null).set("lock_heartbeat", null)
                .set("f_version", nextVersion);
        if (existing.getVersion() == null) {
            update.isNull("f_version");
        } else {
            update.eq("f_version", existing.getVersion());
        }
        return sessionMapper.update(null, update) == 1;
    }

    private OnlyOfficeSessionEntity find(String tenantId, String fileId, String fileType) {
        return sessionMapper.selectOne(Wrappers.<OnlyOfficeSessionEntity>lambdaQuery()
                .eq(OnlyOfficeSessionEntity::getTenantId, tenantId)
                .eq(OnlyOfficeSessionEntity::getFileId, fileId)
                .eq(OnlyOfficeSessionEntity::getFileType, fileType)
                .last("limit 1"));
    }

    private UpdateWrapper<OnlyOfficeSessionEntity> identityUpdate(
            String tenantId, String recordId, String fileId, String fileType) {
        return Wrappers.<OnlyOfficeSessionEntity>update()
                .eq("f_tenant_id", tenantId)
                .eq("file_id", fileId)
                .eq("file_type", fileType)
                .eq("biz_module", ELN_RECORD_BIZ_MODULE)
                .eq("biz_data_id", recordId)
                .and(active -> active.isNull("f_delete_mark").or().eq("f_delete_mark", 0));
    }

    private static void requireIdentity(
            String tenantId, String recordId, String fileId, String fileType) {
        if (!StringUtils.hasText(tenantId) || !StringUtils.hasText(recordId)
                || !StringUtils.hasText(fileId) || !StringUtils.hasText(fileType)) {
            throw new DataException("记录修订 fence 身份参数不完整");
        }
    }

    private static DataException busy() {
        return new DataException("记录文档正在编辑或保存，请关闭编辑器后重试");
    }

    private static DataException cancelled() {
        return new DataException("记录冻结操作已取消，请重新提交");
    }
}