@Entity
@Table(name = "contract")
public class ContractEntity {
    @Id
    @GeneratedValue(generator = "UUID")
    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
    private UUID id;
    
    @Column(nullable = false, unique = true)
    private String code; // номер договора
    
    @Column(nullable = false)
    private String title; // предмет договора
    
    @Column(nullable = false)
    private LocalDate contractDate;
    
    @Column(nullable = false, precision = 15, scale = 2)
    private BigDecimal amount;
    
    @Column(nullable = false)
    private LocalDateTime deadline;
    
    @Column(nullable = false)
    private String contractType; // Купля-продажа / Услуги / Подряд
    
    @Column(nullable = false)
    private String status; // DRAFT, SIGNING, SIGNED
    
    // Аудит
    @Column(nullable = false)
    private UUID createdBy;
    
    @Column(nullable = false)
    private Instant createdAt;
    
    private UUID modifiedBy;
    private Instant modifiedAt;
    
    // геттеры, сеттеры, конструкторы...
}

@Repository
public interface ContractRepository extends JpaRepository<ContractEntity, UUID> {
    
    // Базовые методы поиска
    Optional<ContractEntity> findByCode(String code);
    List<ContractEntity> findByStatus(String status);
    Page<ContractEntity> findByStatusIn(List<String> statuses, Pageable pageable);
    
    // Поиск по датам
    List<ContractEntity> findByContractDateBetween(LocalDate start, LocalDate end);
    List<ContractEntity> findByDeadlineBefore(LocalDateTime date);
    List<ContractEntity> findByDeadlineAfter(LocalDateTime date);
    
    // Поиск по сумме
    List<ContractEntity> findByAmountGreaterThanEqual(BigDecimal amount);
    List<ContractEntity> findByAmountBetween(BigDecimal min, BigDecimal max);
    
    // Поиск по типу договора
    List<ContractEntity> findByContractType(String contractType);
    Page<ContractEntity> findByContractTypeAndStatus(String contractType, String status, Pageable pageable);
    
    // Комбинированные поиски
    List<ContractEntity> findByCodeContainingAndStatus(String codePart, String status);
    Page<ContractEntity> findByTitleContainingIgnoreCase(String titlePart, Pageable pageable);
    
    // Поиск с несколькими условиями
    @Query("SELECT c FROM ContractEntity c WHERE " +
           "(:code IS NULL OR c.code LIKE %:code%) AND " +
           "(:contractType IS NULL OR c.contractType = :contractType) AND " +
           "(:status IS NULL OR c.status = :status) AND " +
           "(c.amount >= :minAmount) AND " +
           "(c.deadline >= :deadlineFrom)")
    Page<ContractEntity> searchContracts(@Param("code") String code,
                                         @Param("contractType") String contractType,
                                         @Param("status") String status,
                                         @Param("minAmount") BigDecimal minAmount,
                                         @Param("deadlineFrom") LocalDateTime deadlineFrom,
                                         Pageable pageable);
    
    // Статистика
    long countByStatus(String status);
    @Query("SELECT c.status, COUNT(c) FROM ContractEntity c GROUP BY c.status")
    List<Object[]> countByStatusGroup();
    
    // Обновление статуса (массовое)
    @Modifying
    @Query("UPDATE ContractEntity c SET c.status = :newStatus WHERE c.id IN :ids AND c.status = :oldStatus")
    int bulkUpdateStatus(@Param("ids") List<UUID> ids,
                         @Param("oldStatus") String oldStatus,
                         @Param("newStatus") String newStatus);
}

@Service
@Transactional
public class ContractService {
    private final ContractRepository repository;
    private final AuthorizationService authService;
    private final AuditService auditService;
    private final FileStorageService fileStorageService;
    
    public ContractEntity create(ContractCreateDto dto, UUID userId) {
        // Проверка прав
        if (!authService.canCreateContract(userId)) {
            throw new AccessDeniedException("Нет прав на создание договора");
        }
        
        ContractEntity entity = new ContractEntity();
        entity.setCode(dto.getCode());
        entity.setTitle(dto.getTitle());
        entity.setContractDate(dto.getContractDate());
        entity.setAmount(dto.getAmount());
        entity.setDeadline(dto.getDeadline());
        entity.setContractType(dto.getContractType());
        entity.setStatus("DRAFT");
        entity.setCreatedBy(userId);
        entity.setCreatedAt(Instant.now());
        
        ContractEntity saved = repository.save(entity);
        auditService.record("CREATE", saved.getId(), userId, null);
        return saved;
    }
    
    public Page<ContractDto> searchContracts(String code, String contractType, 
                                            String status, BigDecimal minAmount,
                                            LocalDateTime deadlineFrom, UUID userId, 
                                            Pageable pageable) {
        List<String> visibleStatuses = authService.getReadableStatuses(userId);
        // Логика поиска с учётом видимых статусов
        return repository.searchContracts(code, contractType, status, minAmount, deadlineFrom, pageable)
            .map(this::toDto);
    }

    public ContractEntity promoteStatus(UUID contractId, UUID userId) {
        ContractEntity contract = repository.findById(contractId)
            .orElseThrow(() -> new NotFoundException("Договор не найден"));
        
        String oldStatus = contract.getStatus();

        // Сложная логика проверки прав в зависимости от статуса
        if ("DRAFT".equals(contract.getStatus())) {
            if (!authService.canPromoteFromDraft(userId, contract)) {
                throw new AccessDeniedException("Нельзя перевести на подпись");
            }
            contract.setStatus("SIGNING");
        } else if ("SIGNING".equals(contract.getStatus())) {
            if (!authService.canPromoteFromSigning(userId, contract)) {
                throw new AccessDeniedException("Нельзя подписать договор");
            }
            contract.setStatus("SIGNED");
        } else {
            throw new IllegalStateException("Недопустимый переход статуса");
        }
        
        contract.setModifiedBy(userId);
        contract.setModifiedAt(Instant.now());
        
        auditService.record("PROMOTE", contractId, userId, 
            "Статус изменён с " + oldStatus + " на " + contract.getStatus());
        
        return repository.save(contract);
    }
    
    public Page<ContractDto> listVisibleContracts(UUID userId, Pageable pageable) {
        // Ручное вычисление видимых статусов на основе ролей пользователя
        List<String> visibleStatuses = authService.getReadableStatuses(userId);
        return repository.findByStatusIn(visibleStatuses, pageable)
            .map(this::toDto);
    }
    
    // Методы: update, delete, demote, getHistory, attachFile, getFiles...
}

@RestController
@RequestMapping("/api/contracts")
public class ContractController {
    @Autowired
    private ContractService contractService;
    
    @PostMapping
    public ResponseEntity<ContractDto> create(@Valid @RequestBody ContractCreateDto dto,
                                               @RequestAttribute UUID userId) {
        return ResponseEntity.ok(contractService.create(dto, userId));
    }
    
    @PostMapping("/{id}/promote")
    public ResponseEntity<ContractDto> promote(@PathVariable UUID id,
                                                @RequestAttribute UUID userId) {
        return ResponseEntity.ok(contractService.promoteStatus(id, userId));
    }
    
    @PostMapping("/{id}/demote")
    public ResponseEntity<ContractDto> demote(@PathVariable UUID id,
                                               @RequestAttribute UUID userId) {
        return ResponseEntity.ok(contractService.demoteStatus(id, userId));
    }
    
    @GetMapping
    public ResponseEntity<Page<ContractDto>> list(@RequestAttribute UUID userId,
                                                  Pageable pageable) {
        return ResponseEntity.ok(contractService.listVisibleContracts(userId, pageable));
    }
    
    @GetMapping("/search")
    public ResponseEntity<Page<ContractDto>> search(@RequestParam(required = false) String code,
                                                     @RequestParam(required = false) String contractType,
                                                     @RequestParam(required = false) String status,
                                                     @RequestParam(required = false) BigDecimal minAmount,
                                                     @RequestParam(required = false) LocalDateTime deadlineFrom,
                                                     @RequestAttribute UUID userId,
                                                     Pageable pageable) {
        return ResponseEntity.ok(contractService.searchContracts(code, contractType, 
            status, minAmount, deadlineFrom, userId, pageable));
    }
    
    @PostMapping("/{id}/files")
    public ResponseEntity<Void> uploadFile(@PathVariable UUID id,
                                           @RequestParam MultipartFile file,
                                           @RequestAttribute UUID userId) {
        contractService.attachFile(id, file, userId);
        return ResponseEntity.ok().build();
    }
    
    @GetMapping("/{id}/history")
    public ResponseEntity<List<AuditRecord>> getHistory(@PathVariable UUID id) {
        return ResponseEntity.ok(auditService.getHistory(id));
    }
    
    // И ещё десяток endpoint'ов: update, delete, getById, downloadFile, release version...
}

public class ContractCreateDto {
    @NotBlank private String code;
    @NotBlank private String title;
    @NotNull private LocalDate contractDate;
    @NotNull @Positive private BigDecimal amount;
    @NotNull private LocalDateTime deadline;
    @NotBlank private String contractType;
    // геттеры, сеттеры
}

public class ContractDto {
    private UUID id;
    private String code;
    private String title;
    private LocalDate contractDate;
    private BigDecimal amount;
    private LocalDateTime deadline;
    private String contractType;
    private String status;
    private UUID createdBy;
    private Instant createdAt;
    private UUID modifiedBy;
    private Instant modifiedAt;
    // геттеры, сеттеры
}

// Маппер (MapStruct)
@Mapper(componentModel = "spring")
public interface ContractMapper {
    ContractEntity toEntity(ContractCreateDto dto);
    ContractDto toDto(ContractEntity entity);
    List<ContractDto> toDtoList(List<ContractEntity> entities);
}