import 'package:fis_jsonrpc/rpc.dart';
import 'package:uuid/uuid.dart';
import 'package:vitalapp/database/db.dart';
import 'package:vitalapp/database/entities/defines.dart';
import 'package:vitalapp/database/entities/exam.dart';
import 'package:vitalapp/database/entities/exam_batch.dart';
import 'package:vitalapp/store/store.dart';

class ExamServiceMock extends VitalExamService {
  ExamServiceMock(super.host);

  @override
  Future<String> createExamAsync(CreateExamRequest request) async {
    final checkBatch =
        await _checkBatch(request.batchNumber!, request.patientCode!);
    if (!checkBatch) {
      return "";
    }

    // 同步Server，新增&更新都走这个接口
    if (request.code != null && request.code!.isNotEmpty) {
      final updateResult = await _updateOfflineExamByCreateRequest(request);
      return updateResult ? request.code! : "";
    }

    final entity = ExamEntity();
    entity.isValid = true;
    entity.syncType = OfflineDataSyncType.create;
    // 本地先生成一个Code，上传后更新
    final uuid = const Uuid().v4().replaceAll('-', '');
    entity.code = "mock_$uuid";
    entity.userCode = Store.user.userCode!;
    entity.patientCode = request.patientCode!;
    entity.batchNumber = request.batchNumber!;
    entity.physicalEaxmNumber = request.physicalExamNumber!;
    entity.templateKey = request.key!;
    entity.templateCode = request.templateCode!;
    entity.dataJson = request.examData!;

    final id = await db.repositories.exam.insert(entity);
    return id > 0 ? entity.code : "";
  }

  /// 目前仅中医体质用
  @override
  Future<bool> updateExamAsync(UpdateExamRequest request) async {
    ExamEntity? entity = await db.repositories.exam.singleByCode(request.code!);
    if (entity == null) {
      // TODO: 此时拿不到批次号、体检号等信息，无法创建完整的离线数据，先直接返回失败
      return false;
    }

    entity.dataJson = request.examData!;
    final rows = await db.repositories.exam.update(entity);
    return rows > 0;
  }

  @override
  Future<bool> updateExamByBatchNumberAsync(
      UpdateExamByBatchNumberRequest request) async {
    final entity = await db.repositories.exam.queryable
        .where((x) => [
              x.isValid.equals(true),
              x.batchNumber.equals(request.batchNumber),
              x.batchNumber.equals(request.batchNumber),
              x.templateKey.equals(request.key),
            ])
        .first();
    if (entity == null) {
      // TODO: 此时拿不到批次号、体检号等信息，无法创建完整的离线数据，先直接返回失败
      return false;
    }
    entity.dataJson = request.examData!;
    final rows = await db.repositories.exam.update(entity);
    return rows > 0;
  }

  @override
  Future<List<ExamDTO>> getExamByBatchNumberAsync(
      GetExamByBatchNumberRequest request) async {
    final entities = await db.repositories.exam.queryable
        .where((x) => [
              x.isValid.equals(true),
              x.isValid.equals(request.batchNumber),
            ])
        .toList();
    List<ExamDTO> dtos = [];
    for (var entity in entities) {
      final dto = ExamDTO(
        code: entity.code,
      );
      dtos.add(dto);
    }
    return dtos;
  }

  @override
  Future<PageCollection<ExamConclusionDTO>> getPatientExamByPageAsync(
      GetPatientExamByPageRequest request) async {
    var query = db.repositories.exam.queryable.where((x) => [
          x.isValid.equals(true),
        ]);
    final count = await query.count();
    final result = PageCollection<ExamConclusionDTO>(
      currentPage: request.pageIndex,
      pageIndex: request.pageIndex,
      pageSize: request.pageSize,
      totalCount: count,
      dataCount: 0,
      pageData: [],
    );
    return super.getPatientExamByPageAsync(request);
  }

  @override
  Future<List<ExamRecordDTO>> getExamRecordListAsync(
      GetExamRecordListRequest request) async {
    final batchEntities = await db.repositories.examBatch
        .queryPatientAllList(request.patientCode!, Store.user.userCode!);
    if (batchEntities.isEmpty) {
      return [];
    }
    // TODO: implement getExamRecordListAsync
    return super.getExamRecordListAsync(request);
  }

  Future<bool> _updateOfflineExamByCreateRequest(
      CreateExamRequest request) async {
    ExamEntity entity;

    ExamEntity? history =
        await db.repositories.exam.singleByCode(request.code!);

    if (history == null) {
      entity = ExamEntity();
      entity.isValid = true;
      entity.syncType = OfflineDataSyncType.create;
      entity.code = request.code!;
    } else {
      entity = history;
    }

    int result;
    if (entity.id > 0) {
      result = await db.repositories.exam.update(entity);
    } else {
      result = await db.repositories.exam.insert(entity);
    }
    return result > 0;
  }

  Future<bool> _checkBatch(String batchNumber, String patientCode) async {
    final hisCount = await db.repositories.examBatch.queryable
        .where((x) => [
              x.isValid.equals(true),
              x.batchNumber.equals(batchNumber),
              x.patientCode.equals(patientCode),
            ])
        .count();
    if (hisCount > 0) {
      // 已存在。不重复创建
      return true;
    }
    final entity = ExamBatchEntity();
    entity.isValid = true;
    entity.batchNumber = batchNumber;
    entity.patientCode = patientCode;
    entity.userCode = Store.user.userCode!;
    entity.syncType = OfflineDataSyncType.create;
    final batchId = await db.repositories.examBatch.insert(entity);
    return batchId > 0;
  }
}