import 'package:chicken_farm/core/api/api_option.dart';
import 'package:chicken_farm/core/api/api_service.dart';
import 'package:chicken_farm/core/config/app_config.dart';
import 'package:chicken_farm/core/config/breed_config.dart';
import 'package:chicken_farm/core/db/table_config.dart';
import 'package:chicken_farm/core/services/breeding_data_service.dart';
import 'package:chicken_farm/modes/api/result_model.dart';

class BreedSubmitApi {
  static final BreedSubmitApi _instance = BreedSubmitApi._internal();

  factory BreedSubmitApi() => _instance;

  BreedSubmitApi._internal();
  final BreedingDataService _breedingDataService = BreedingDataService();
  static final String apiPrefix = '/app/breeding';

  final String bindChickenUrl = '$apiPrefix/batchAddChicken';
  final String cageChangeUrl = '$apiPrefix/batchChangeCage';
  final String weightUrl = '$apiPrefix/batchChickenWeight';
  final String cullUrl = '$apiPrefix/batchCullChicken';

  Future<ResultModel> bindChicken(dynamic data) async {
    try {
      List<String> ids = data['electronicIds'];
      // 保存到本地数据库
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'electronicId': id,
          'batchNum': data['batchNum'],
          'familyNum': data['familyNum'],
          // 'cageNum': data['cageNum'],
          // 'gender': data['gender'] ?? 2,
          'isExport': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline &&
          await _breedingDataService.queryCount(TableConfig.chicken) == 0) {
        result = await ApiService().post(
          bindChickenUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(
          TableConfig.chicken,
          list,
        );
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cageChange(dynamic data) async {
    try {
      final ids = data['electronicIds'] as List<String>;
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'electronicId': id,
          'targetCageNum': data['targetCage'],
          'bindTime': data['date'],
          'isExport': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline &&
          await _breedingDataService.queryCount(TableConfig.chicken) == 0) {
        result = await ApiService().post(
          cageChangeUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(
          TableConfig.cageChange,
          list,
        );
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> weight(dynamic data) async {
    try {
      Map<String, dynamic> weightData = {
        'electronicId': data['electronicId'],
        'weightValue': data['weight'],
        'recordDate': data['date'],
        'isExport': 0,
      };
      List<Map<String, dynamic>> list = [weightData].toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline &&
          await _breedingDataService.queryCount(TableConfig.chicken) == 0) {
        result = await ApiService().post(
          weightUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(TableConfig.weight, list);
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> cull(dynamic data) async {
    try {
      List<Map<String, dynamic>> list = [
        {
          'electronicId': data['electronicId'],
          'cullReason': data['cullReason'],
          'disposalMethod': data['disposalMethod'],
          'cullTime': data['date'],
          'isExport': 0,
        },
      ];
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline &&
          await _breedingDataService.queryCount(TableConfig.chicken) == 0) {
        result = await ApiService().post(
          cullUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(TableConfig.cull, list);
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> batchCull(dynamic data) async {
    try {
      List<String> ids = data['electronicIds'];
      List<Map<String, dynamic>> list = ids.map<Map<String, dynamic>>((id) {
        return {
          'electronicId': data['electronicId'],
          'cullReason': data['cullReason'],
          'disposalMethod': data['disposalMethod'],
          'cullTime': data['date'],
          'isExport': 0,
        };
      }).toList();
      ResultModel result = ResultModel.offline();
      if (!AppConfig.isOffline &&
          await _breedingDataService.queryCount(TableConfig.chicken) == 0) {
        result = await ApiService().post(
          cullUrl,
          data: list,
          apiOption: ApiOption.noAlert(),
        );
      }
      if (result.isOffline == true || result.isNetError == true) {
        return await _breedingDataService.batchInsert(TableConfig.cull, list);
      } else {
        return result;
      }
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  Future<ResultModel> upload(String type, Map<String, dynamic> data) async {
    try {
      if (AppConfig.isOffline) {
        return ResultModel.failOffline("脱机模式不支持调用upload接口");
      }
      String url = getUrl(type);
      if (url.isEmpty) {
        return ResultModel.fail("上传接口不存在");
      }
      return await ApiService().post(
        url,
        data: data,
        apiOption: ApiOption.noAlert(),
      );
    } catch (e) {
      return ResultModel(success: false, message: e.toString(), data: null);
    }
  }

  String getUrl(String type) {
    switch (type) {
      case BreedConfig.chicken:
        return '$apiPrefix/bindChicken';
      case BreedConfig.cageChange:
        return '$apiPrefix/cageChange';
      case BreedConfig.weight:
        return '$apiPrefix/weight';
      case BreedConfig.cull:
        return '$apiPrefix/cull';
      default:
        return '';
    }
  }
}