//package com.qqchen.deploy.backend.service.impl;
//
//import com.qqchen.application.dto.RepositorySyncStatusDTO;
//import com.qqchen.application.dto.RunningSyncDTO;
//import com.qqchen.application.dto.TestConnectionDTO;
//import com.qqchen.application.service.RepositoryService;
//import com.qqchen.common.exception.ApiException;
//import com.qqchen.domain.entity.RepositoryBranch;
//import com.qqchen.domain.entity.RepositoryConfig;
//import com.qqchen.domain.entity.RepositoryGroup;
//import com.qqchen.domain.entity.RepositoryProject;
//import com.qqchen.domain.entity.RepositorySyncHistory;
//import com.qqchen.domain.repository.RepositoryBranchRepository;
//import com.qqchen.domain.repository.RepositoryConfigRepository;
//import com.qqchen.domain.repository.RepositoryGroupRepository;
//import com.qqchen.domain.repository.RepositoryProjectRepository;
//import com.qqchen.domain.repository.RepositorySyncHistoryRepository;
//import lombok.Getter;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.boot.web.client.RestTemplateBuilder;
//import org.springframework.core.ParameterizedTypeReference;
//import org.springframework.core.task.AsyncTaskExecutor;
//import org.springframework.http.HttpEntity;
//import org.springframework.http.HttpHeaders;
//import org.springframework.http.HttpMethod;
//import org.springframework.http.HttpStatus;
//import org.springframework.http.MediaType;
//import org.springframework.http.ResponseEntity;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.PlatformTransactionManager;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.transaction.support.TransactionTemplate;
//import org.springframework.web.client.RestTemplate;
//
//import java.time.Duration;
//import java.time.LocalDateTime;
//import java.util.Collection;
//import java.util.Collections;
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.CompletableFuture;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Service
//@RequiredArgsConstructor
//public class RepositoryServiceImpl implements RepositoryService {
//
//    private final RepositoryConfigRepository configRepository;
//
//    private final RepositoryGroupRepository groupRepository;
//
//    private final RepositoryProjectRepository projectRepository;
//
//    private final RepositoryBranchRepository branchRepository;
//
//    private final RepositorySyncHistoryRepository syncHistoryRepository;
//
//    private final AsyncTaskExecutor taskExecutor;
//
//    private final PlatformTransactionManager transactionManager;
//
//    // 使用 ConcurrentHashMap 记录正在执行的任务
//    private static final Map<Long, Boolean> RUNNING_TASKS = new ConcurrentHashMap<>();
//
//    private RestTemplate createRestTemplate() {
//        return new RestTemplateBuilder()
//            .setConnectTimeout(Duration.ofSeconds(30))
//            .setReadTimeout(Duration.ofSeconds(30))
//            .build();
//    }
//
//    private HttpEntity<String> createHttpEntity(String accessToken) {
//        HttpHeaders headers = new HttpHeaders();
//        headers.set("PRIVATE-TOKEN", accessToken.trim());
//        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
//        return new HttpEntity<>(headers);
//    }
//
//    @Override
//    public List<RepositoryConfig> listConfigs() {
//        return configRepository.findByDeletedFalseOrderBySort();
//    }
//
//    @Override
//    @Transactional
//    public RepositoryConfig createConfig(RepositoryConfig config) {
//        if (configRepository.existsByNameAndDeletedFalse(config.getName())) {
//            throw new ApiException("仓库名称已存在");
//        }
//
//        if (!testConnection(config)) {
//            throw new ApiException("仓库连接测试失败");
//        }
//
//        return configRepository.save(config);
//    }
//
//    @Override
//    @Transactional
//    public RepositoryConfig updateConfig(Long id, RepositoryConfig config) {
//        RepositoryConfig existing = configRepository.findById(id)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//
//        if (!existing.getName().equals(config.getName())
//            && configRepository.existsByNameAndDeletedFalse(config.getName())) {
//            throw new ApiException("仓库名称已存在");
//        }
//
//        if (!existing.getUrl().equals(config.getUrl())
//            || !existing.getAccessToken().equals(config.getAccessToken())) {
//            if (!testConnection(config)) {
//                throw new ApiException("仓库连接测试失败");
//            }
//        }
//
//        config.setId(id);
//        config.setVersion(existing.getVersion());
//        config.setDeleted(existing.getDeleted());
//        return configRepository.save(config);
//    }
//
//    @Override
//    @Transactional
//    public void deleteConfig(Long id) {
//        RepositoryConfig config = configRepository.findById(id)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//
//        config.setDeleted(true);
//        configRepository.save(config);
//    }
//
//    @Override
//    public boolean testConnection(RepositoryConfig config) {
//        try {
//            String url = String.format("%s/api/v4/user", config.getUrl().trim());
//            ResponseEntity<Map> response = createRestTemplate().exchange(
//                url,
//                HttpMethod.GET,
//                createHttpEntity(config.getAccessToken()),
//                Map.class
//            );
//
//            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
//                log.info("测试连接成功，用户: {}", response.getBody().get("username"));
//                return true;
//            }
//
//            log.error("测试连接失败: 响应状态码 {}", response.getStatusCode());
//            return false;
//        } catch (Exception e) {
//            log.error("测试连接失败: {}", e.getMessage());
//            return false;
//        }
//    }
//
//    @Override
//    public boolean testConnection(TestConnectionDTO dto) {
//        try {
//            String url = String.format("%s/api/v4/user", dto.getUrl().trim());
//            ResponseEntity<Map> response = createRestTemplate().exchange(
//                url,
//                HttpMethod.GET,
//                createHttpEntity(dto.getAccessToken()),
//                Map.class
//            );
//
//            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
//                log.info("测试连接成功，用户: {}", response.getBody().get("username"));
//                return true;
//            }
//
//            log.error("测试连接失败: 响应状态码 {}", response.getStatusCode());
//            return false;
//        } catch (Exception e) {
//            log.error("测试连接失败: {}", e.getMessage());
//            return false;
//        }
//    }
//
//    @Override
//    @Transactional
//    public Long asyncSyncAll(Long repositoryId) {
//        // 检查是否已有同步任务在运行
//        if (RUNNING_TASKS.containsKey(repositoryId)) {
//            throw new ApiException("该仓库已有同步任务正在运行中");
//        }
//        
//        log.info("开始异步同步仓库数据, repositoryId: {}", repositoryId);
//        
//        RepositoryConfig config = configRepository.findById(repositoryId)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//
//        // 创建同步历史记录
//        RepositorySyncHistory history = new RepositorySyncHistory();
//        history.setRepositoryId(repositoryId);
//        history.setSyncType(RepositorySyncHistory.SyncType.GROUP);
//        history.setStartTime(LocalDateTime.now());
//        history.setStatus(RepositorySyncHistory.SyncStatus.RUNNING);
//        syncHistoryRepository.save(history);
//        
//        // 标记任务开始运行
//        RUNNING_TASKS.put(repositoryId, true);
//        
//        taskExecutor.execute(() -> {
//            // 用于存储同步过程中的错误信息
//            StringBuilder errorMessages = new StringBuilder();
//            
//            try {
//                RestTemplate restTemplate = createRestTemplate();
//                HttpEntity<String> entity = createHttpEntity(config.getAccessToken());
//
//                // 1. 同步所有数据到内存
//                RepositorySyncDataCache dataHolder = new RepositorySyncDataCache();
//                
//                // 2. 同步群组数据
//                try {
//                    CompletableFuture<Boolean> groupsFuture = syncGroupsParallel(config, entity, restTemplate, dataHolder);
//                    boolean groupsSuccess = groupsFuture.get(10, TimeUnit.MINUTES);
//                    if (!groupsSuccess) {
//                        errorMessages.append("群组同步失败; ");
//                    }
//                } catch (Exception e) {
//                    log.error("群组同步失败", e);
//                    errorMessages.append("群组同步异常: ").append(e.getMessage()).append("; ");
//                }
//
//                // 3. 如果同步成功，同步项目数据
//                if (errorMessages.isEmpty() && !dataHolder.getGroups().isEmpty()) {
//                    try {
//                        CompletableFuture<Boolean> projectsFuture = syncProjectsParallel(
//                            config, entity, restTemplate, dataHolder.getGroups().values(), dataHolder);
//                        boolean projectsSuccess = projectsFuture.get(10, TimeUnit.MINUTES);
//                        if (!projectsSuccess) {
//                            errorMessages.append("项目同步失败; ");
//                        }
//                    } catch (Exception e) {
//                        log.error("项目同步失败", e);
//                        errorMessages.append("项目同步异常: ").append(e.getMessage()).append("; ");
//                    }
//                }
//
//                // 4. 如果项目同步成功，同步分支数据
//                if (errorMessages.isEmpty() && !dataHolder.getProjects().isEmpty()) {
//                    try {
//                        CompletableFuture<Boolean> branchesFuture = syncBranchesParallel(
//                            config, entity, restTemplate, dataHolder.getProjects().values(), dataHolder);
//                        boolean branchesSuccess = branchesFuture.get(10, TimeUnit.MINUTES);
//                        if (!branchesSuccess) {
//                            errorMessages.append("分支同步失败; ");
//                        }
//                    } catch (Exception e) {
//                        log.error("分支同步失败", e);
//                        errorMessages.append("分支同步异常: ").append(e.getMessage()).append("; ");
//                    }
//                }
//
//                // 5. 如果所有数据都同步成功，在新的事务中更新数据库
//                if (errorMessages.isEmpty()) {
//                    try {
//                        updateDatabaseWithTransaction(repositoryId, dataHolder);
//                        updateSyncHistory(history, RepositorySyncHistory.SyncStatus.SUCCESS, null);
//                        log.info("仓库数据同步完成, repositoryId: {}", repositoryId);
//                    } catch (Exception e) {
//                        log.error("数据库更新失败", e);
//                        errorMessages.append("数据库更新失败: ").append(e.getMessage());
//                        updateSyncHistory(history, RepositorySyncHistory.SyncStatus.FAILED, errorMessages.toString());
//                    }
//                } else {
//                    updateSyncHistory(history, RepositorySyncHistory.SyncStatus.FAILED, errorMessages.toString());
//                }
//            } catch (Exception e) {
//                log.error("仓库数同步失败", e);
//                updateSyncHistory(history, RepositorySyncHistory.SyncStatus.FAILED, e.getMessage());
//            } finally {
//                // 无论成功失败，都移除运行标记
//                RUNNING_TASKS.remove(repositoryId);
//            }
//        });
//
//        return history.getId();
//    }
//
//    // 使用编程式事务
//    private void updateDatabaseWithTransaction(Long repositoryId, RepositorySyncDataCache dataHolder) {
//        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
//        transactionTemplate.execute(status -> {
//            try {
//                updateDatabase(repositoryId, dataHolder);
//                return null;
//            } catch (Exception e) {
//                status.setRollbackOnly();
//                throw e;
//            }
//        });
//    }
//
//    // 实际的数据库更新操作
//    private void updateDatabase(Long repositoryId, RepositorySyncDataCache dataHolder) {
//        log.info("开始更新数据库...");
//        
//        try {
//            // 1. 删除旧数据
//            log.info("删除旧数据...");
//            branchRepository.deleteByRepositoryId(repositoryId);
//            projectRepository.deleteByRepositoryId(repositoryId);
//            groupRepository.deleteByRepositoryId(repositoryId);
//
//            // 2. 保存新数据
//            log.info("保存新数据...");
//            if (!dataHolder.getGroups().isEmpty()) {
//                groupRepository.saveAll(dataHolder.getGroups().values());
//            }
//            if (!dataHolder.getProjects().isEmpty()) {
//                projectRepository.saveAll(dataHolder.getProjects().values());
//            }
//            if (!dataHolder.getBranches().isEmpty()) {
//                branchRepository.saveAll(dataHolder.getBranches().values());
//            }
//            
//            log.info("数据库更新完成");
//        } catch (Exception e) {
//            log.error("数据库更新失败", e);
//            throw new ApiException("数据库更新失败: " + e.getMessage());
//        }
//    }
//
//    private CompletableFuture<Boolean> syncGroupsParallel(
//            RepositoryConfig config, 
//            HttpEntity<String> entity,
//            RestTemplate restTemplate,
//            RepositorySyncDataCache dataHolder) {
//        
//        String groupsUrl = String.format("%s/api/v4/groups?per_page=100", config.getUrl());
//        try {
//            log.info("开始同步群组 - 仓库: {}", config.getName());
//            
//            ResponseEntity<List<Map<String, Object>>> response = restTemplate.exchange(
//                groupsUrl,
//                HttpMethod.GET,
//                entity,
//                new ParameterizedTypeReference<>() {}
//            );
//
//            if (response.getBody() == null) {
//                log.warn("未获取到群组数据 - 仓库: {}", config.getName());
//                return CompletableFuture.completedFuture(true);
//            }
//
//            for (Map<String, Object> group : response.getBody()) {
//                try {
//                    RepositoryGroup repositoryGroup = createGroup(config.getId(), group);
//                    dataHolder.getGroups().put(repositoryGroup.getGroupId(), repositoryGroup);
//                } catch (Exception e) {
//                    log.error("处理群组失败 - 仓库: {}, 群组: {}, 错误: {}", 
//                        config.getName(), group.get("name"), e.getMessage());
//                }
//            }
//
//            log.info("群组同步完成 - 仓库: {}, 总数: {}", config.getName(), response.getBody().size());
//            return CompletableFuture.completedFuture(true);
//        } catch (Exception e) {
//            log.error("同步群组失败 - 仓库: {}, 错误: {}", config.getName(), e.getMessage());
//            return CompletableFuture.completedFuture(false);
//        }
//    }
//
//    private CompletableFuture<Boolean> syncProjectsParallel(
//            RepositoryConfig config,
//            HttpEntity<String> entity,
//            RestTemplate restTemplate,
//            Collection<RepositoryGroup> groups,
//            RepositorySyncDataCache dataHolder) {
//
//        try {
//            log.info("开始同步项目 - 仓库: {}", config.getName());
//            
//            for (RepositoryGroup group : groups) {
//                try {
//                    String projectsUrl = String.format("%s/api/v4/groups/%s/projects?per_page=100",
//                        config.getUrl(), group.getGroupId());
//                        
//                    ResponseEntity<List<Map<String, Object>>> response = restTemplate.exchange(
//                        projectsUrl,
//                        HttpMethod.GET,
//                        entity,
//                        new ParameterizedTypeReference<>() {}
//                    );
//
//                    if (response.getBody() == null) {
//                        continue;
//                    }
//
//                    for (Map<String, Object> project : response.getBody()) {
//                        try {
//                            RepositoryProject repositoryProject = createProject(config.getId(), project);
//                            dataHolder.getProjects().put(repositoryProject.getProjectId(), repositoryProject);
//                        } catch (Exception e) {
//                            log.error("处理项目失败 - 仓库: {}, 项目: {}, 错误: {}", 
//                                config.getName(), project.get("name"), e.getMessage());
//                        }
//                    }
//                } catch (Exception e) {
//                    log.error("处理群组项目失败 - 仓库: {}, 群组: {}, 错误: {}", 
//                        config.getName(), group.getName(), e.getMessage());
//                }
//            }
//
//            log.info("项目同步完成 - 仓库: {}", config.getName());
//            return CompletableFuture.completedFuture(true);
//        } catch (Exception e) {
//            log.error("同步项目失败 - 仓库: {}, 错误: {}", config.getName(), e.getMessage());
//            return CompletableFuture.completedFuture(false);
//        }
//    }
//
//    private CompletableFuture<Boolean> syncBranchesParallel(
//            RepositoryConfig config,
//            HttpEntity<String> entity,
//            RestTemplate restTemplate,
//            Collection<RepositoryProject> projects,
//            RepositorySyncDataCache dataHolder) {
//
//        try {
//            log.info("开始同步分支 - 仓库: {}", config.getName());
//            
//            for (RepositoryProject project : projects) {
//                try {
//                    String branchesUrl = String.format("%s/api/v4/projects/%s/repository/branches",
//                        config.getUrl(), project.getProjectId());
//                        
//                    ResponseEntity<List<Map<String, Object>>> response = restTemplate.exchange(
//                        branchesUrl,
//                        HttpMethod.GET,
//                        entity,
//                        new ParameterizedTypeReference<>() {}
//                    );
//
//                    if (response.getBody() == null) {
//                        continue;
//                    }
//
//                    for (Map<String, Object> branch : response.getBody()) {
//                        try {
//                            RepositoryBranch repositoryBranch = createBranch(
//                                config.getId(), 
//                                project.getProjectId().toString(), 
//                                branch
//                            );
//                            dataHolder.getBranches().put(
//                                project.getProjectId() + "-" + repositoryBranch.getName(),
//                                repositoryBranch
//                            );
//                        } catch (Exception e) {
//                            log.error("处理分支失败 - 仓库: {}, 项目: {}, 分支: {}, 错误: {}", 
//                                config.getName(), project.getName(), branch.get("name"), e.getMessage());
//                        }
//                    }
//                } catch (Exception e) {
//                    log.error("处理项目分支失败 - 仓库: {}, 项目: {}, 错误: {}", 
//                        config.getName(), project.getName(), e.getMessage());
//                }
//            }
//
//            log.info("分支同步完成 - 仓库: {}", config.getName());
//            return CompletableFuture.completedFuture(true);
//        } catch (Exception e) {
//            log.error("同步分支失败 - 仓库: {}, 错误: {}", config.getName(), e.getMessage());
//            return CompletableFuture.completedFuture(false);
//        }
//    }
//
//    @Override
//    public RepositorySyncStatusDTO getSyncStatus(Long historyId) {
//        RepositorySyncHistory history = syncHistoryRepository.findById(historyId)
//            .orElseThrow(() -> new ApiException("同步历史记录不存在"));
//            
//        return RepositorySyncStatusDTO.builder()
//            .status(history.getStatus())
//            .startTime(history.getStartTime())
//            .endTime(history.getEndTime())
//            .errorMessage(history.getErrorMessage())
//            .build();
//    }
//
//    private void updateSyncHistory(RepositorySyncHistory history, 
//                                 RepositorySyncHistory.SyncStatus status,
//                                 String errorMessage) {
//        // 更新同步历史记录
//        history.setStatus(status);
//        history.setEndTime(LocalDateTime.now());
//        history.setErrorMessage(errorMessage);
//        syncHistoryRepository.save(history);
//        
//        // 更新仓库配置的最后同步状态
//        RepositoryConfig config = configRepository.findById(history.getRepositoryId())
//            .orElse(null);
//        if (config != null) {
//            config.setLastSyncTime(history.getEndTime());
//            config.setLastSyncStatus(status);
//            configRepository.save(config);
//            log.info("更新仓库同步状态 - 仓库: {}, 状态: {}, 时间: {}", 
//                config.getName(), status, history.getEndTime());
//        }
//    }
//
//    // 创建群组对象（不保存到数据库）
//    private RepositoryGroup createGroup(Long repositoryId, Map<String, Object> group) {
//        RepositoryGroup repositoryGroup = new RepositoryGroup();
//        repositoryGroup.setRepositoryId(repositoryId);
//        repositoryGroup.setGroupId(Long.valueOf(group.get("id").toString()));
//        repositoryGroup.setName((String) group.get("name"));
//        repositoryGroup.setPath((String) group.get("path"));
//        repositoryGroup.setDescription((String) group.get("description"));
//        repositoryGroup.setVisibility((String) group.get("visibility"));
//        repositoryGroup.setWebUrl((String) group.get("web_url"));
//        return repositoryGroup;
//    }
//
//    // 创建项目对象（不保存到数据库）
//    private RepositoryProject createProject(Long repositoryId, Map<String, Object> project) {
//        RepositoryProject repositoryProject = new RepositoryProject();
//        repositoryProject.setRepositoryId(repositoryId);
//        repositoryProject.setProjectId(Long.valueOf(project.get("id").toString()));
//        repositoryProject.setName((String) project.get("name"));
//        repositoryProject.setPath((String) project.get("path"));
//        repositoryProject.setDescription((String) project.get("description"));
//        repositoryProject.setVisibility((String) project.get("visibility"));
//        repositoryProject.setDefaultBranch((String) project.get("default_branch"));
//        repositoryProject.setWebUrl((String) project.get("web_url"));
//        repositoryProject.setSshUrl((String) project.get("ssh_url_to_repo"));
//        repositoryProject.setHttpUrl((String) project.get("http_url_to_repo"));
//        return repositoryProject;
//    }
//
//    // 创建分支对象（不保存到数据库）
//    private RepositoryBranch createBranch(Long repositoryId, String projectId, Map<String, Object> branch) {
//        RepositoryBranch repositoryBranch = new RepositoryBranch();
//        repositoryBranch.setRepositoryId(repositoryId);
//        repositoryBranch.setProjectId(Long.valueOf(projectId));
//        repositoryBranch.setName((String) branch.get("name"));
//
//        Map<String, Object> commit = (Map<String, Object>) branch.get("commit");
//        if (commit != null) {
//            repositoryBranch.setCommitId((String) commit.get("id"));
//            repositoryBranch.setCommitMessage((String) commit.get("message"));
//            repositoryBranch.setCommitAuthor((String) commit.get("author_name"));
//            String commitDate = (String) commit.get("committed_date");
//            if (commitDate != null) {
//                repositoryBranch.setCommitDate(LocalDateTime.parse(commitDate.substring(0, 19)));
//            }
//        }
//
//        repositoryBranch.setProtected_((Boolean) branch.get("protected"));
//        repositoryBranch.setDevelopersCanPush((Boolean) branch.get("developers_can_push"));
//        repositoryBranch.setDevelopersCanMerge((Boolean) branch.get("developers_can_merge"));
//        return repositoryBranch;
//    }
//
//    @Override
//    public void syncAll(Long repositoryId) {
//        // 为了保向后兼容，我们调用新的异步方法
//        asyncSyncAll(repositoryId);
//    }
//
//    @Override
//    public void syncGroups(Long repositoryId) {
//        // 实现群组同步
//        log.info("开始同步群组数据, repositoryId: {}", repositoryId);
//        RepositoryConfig config = configRepository.findById(repositoryId)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//        
//        RestTemplate restTemplate = createRestTemplate();
//        HttpEntity<String> entity = createHttpEntity(config.getAccessToken());
//        RepositorySyncDataCache dataHolder = new RepositorySyncDataCache();
//        
//        try {
//            syncGroupsParallel(config, entity, restTemplate, dataHolder).get(10, TimeUnit.MINUTES);
//            updateDatabase(repositoryId, dataHolder);
//        } catch (Exception e) {
//            log.error("群组同步失败", e);
//            throw new ApiException("群组同步失败: " + e.getMessage());
//        }
//    }
//
//    @Override
//    public void syncProjects(Long repositoryId, Long groupId) {
//        // 实现项目同步
//        log.info("开始同步项目数据, repositoryId: {}, groupId: {}", repositoryId, groupId);
//        RepositoryConfig config = configRepository.findById(repositoryId)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//        
//        RepositoryGroup group = groupRepository.findByRepositoryIdAndGroupId(repositoryId, groupId)
//            .orElseThrow(() -> new ApiException("群组不存在"));
//        
//        RestTemplate restTemplate = createRestTemplate();
//        HttpEntity<String> entity = createHttpEntity(config.getAccessToken());
//        RepositorySyncDataCache dataHolder = new RepositorySyncDataCache();
//        
//        try {
//            List<RepositoryGroup> groups = Collections.singletonList(group);
//            syncProjectsParallel(config, entity, restTemplate, groups, dataHolder).get(10, TimeUnit.MINUTES);
//            updateDatabase(repositoryId, dataHolder);
//        } catch (Exception e) {
//            log.error("项目同步失败", e);
//            throw new ApiException("项目同步失败: " + e.getMessage());
//        }
//    }
//
//    @Override
//    public void syncBranches(Long repositoryId, Long projectId) {
//        // 实现分支同步
//        log.info("开始同步分支数据, repositoryId: {}, projectId: {}", repositoryId, projectId);
//        RepositoryConfig config = configRepository.findById(repositoryId)
//            .orElseThrow(() -> new ApiException("仓库配置不存在"));
//        
//        RepositoryProject project = projectRepository.findByRepositoryIdAndProjectId(repositoryId, projectId)
//            .orElseThrow(() -> new ApiException("项目不存在"));
//        
//        RestTemplate restTemplate = createRestTemplate();
//        HttpEntity<String> entity = createHttpEntity(config.getAccessToken());
//        RepositorySyncDataCache dataHolder = new RepositorySyncDataCache();
//        
//        try {
//            List<RepositoryProject> projects = Collections.singletonList(project);
//            syncBranchesParallel(config, entity, restTemplate, projects, dataHolder).get(10, TimeUnit.MINUTES);
//            updateDatabase(repositoryId, dataHolder);
//        } catch (Exception e) {
//            log.error("分支同步失败", e);
//            throw new ApiException("分支同步失败: " + e.getMessage());
//        }
//    }
//
//    @Override
//    public List<RunningSyncDTO> getRunningSyncs() {
//        // 查询最近的50条同步历史记录
//        List<RepositorySyncHistory> histories = syncHistoryRepository
//            .findTop50ByOrderByStartTimeDesc();
//        
//        return histories.stream()
//            .map(history -> {
//                RepositoryConfig config = configRepository
//                    .findById(history.getRepositoryId())
//                    .orElse(null);
//                    
//                // 检查任务是否真正在运行
//                boolean isActuallyRunning = RUNNING_TASKS.containsKey(history.getRepositoryId());
//                
//                // 如果数据库状态为 RUNNING 但实际未运行，更新状态为 FAILED
//                if (history.getStatus() == RepositorySyncHistory.SyncStatus.RUNNING 
//                    && !isActuallyRunning) {
//                    history.setStatus(RepositorySyncHistory.SyncStatus.FAILED);
//                    history.setErrorMessage("同步任务意外终止");
//                    history.setEndTime(LocalDateTime.now());
//                    syncHistoryRepository.save(history);
//                }
//                
//                return RunningSyncDTO.builder()
//                    .historyId(history.getId())
//                    .repositoryId(history.getRepositoryId())
//                    .repositoryName(config != null ? config.getName() : "未知仓库")
//                    .startTime(history.getStartTime())
//                    .syncType(history.getSyncType().name())
//                    .status(history.getStatus())
//                    .endTime(history.getEndTime())
//                    .errorMessage(history.getErrorMessage())
//                    .isActuallyRunning(isActuallyRunning)  // 添加实际运行状态
//                    .build();
//            })
//            .collect(Collectors.toList());
//    }
//
//    // ... 继续实现其他方法吗？
//
//    /**
//     * 仓库同步数据缓存，用于在同步过程中临时存储数据
//     */
//    @Getter
//    private static class RepositorySyncDataCache {
//        // 使用 ConcurrentHashMap 确保线程安全
//        private final Map<Long, RepositoryGroup> groups = new ConcurrentHashMap<>();
//        private final Map<Long, RepositoryProject> projects = new ConcurrentHashMap<>();
//        private final Map<String, RepositoryBranch> branches = new ConcurrentHashMap<>();
//    }
//} 