import 'dart:ffi';

import 'package:flutter/material.dart';
import 'package:one_key/constant/state.dart';
import 'package:one_key/models/plan_cook_by_rid_model.dart';
import 'package:one_key/models/plan_cook_list_model.dart';
import 'package:one_key/net/base_resp.dart';
import 'package:one_key/net/dio_util.dart';
import 'package:one_key/utils/utils.dart';

import '../constant/constant.dart';
import '../constant/error.dart';
import '../models/cookbook_model.dart';
import '../models/seller_often_model.dart';
import '../net/http_url.dart';

/**
 * 预排菜
 */
class PlanDishProvider extends ChangeNotifier {
  PageState pageStateHome = PageState.Loading;
  PageState pageState = PageState.Loading;
  PageState pageStateStore = PageState.Success;
  PageState pageStateMine = PageState.Success;
  PageState pageStateMy = PageState.Loading;

  PageState pageStateMenu = PageState.Loading;

  List<MenuModel> menuModel; //菜品数据
  List<MenuModel> menuModelForManager = []; //经理点菜菜品数据

  List<SunListPlan> allList = []; //排菜套餐列表--全部
  List<SunListPlan> storeList = []; //排菜套餐列表--店铺
  List<SunListPlan> mineList = []; //排菜套餐列表--我的

  List<SunListPlan> storeListTemp = []; //排菜套餐列表--店铺
  List<SunListPlan> mineListTemp = []; //排菜套餐列表--我的
  String planId;
  PlanCookByRidSunModel planCookByRidSunModel; //订单排菜的数据
  List<MenuSunModel> sellerOftendata; //店内常点
  List<MenuSunModel> sellerOftendataTemp = []; //店内常点
  // List<CookbookCategorySunModel> categorySunModel; //菜品分类数据
  // List<CookbookSpecSunModel> specSunModel; //计价单位

  // CookbookOneSunModel cookbookOneSunModel;

  ///分类下所有菜品列表(1.传orderid顾客端获取带订单信息的 否则不传

  getCookbookByClass(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.get_cookbook_by_class,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {
        switch (error.type) {
          case 1:
            pageState = PageState.ConnectivityError;
            break;
          case 2:
            pageState = PageState.ConnectivityTimeOut;
            break;
          default:
            pageState = PageState.ConnectivityError;
            break;
        }
      }
      notifyListeners();
      return false;
    });
    menuModel = [];

    if (baseResp != null && baseResp.code == Constant.status_success) {
      if (baseResp.data[0]['list'] == '') {
        pageState = PageState.Empty;
      } else {
        List menu = baseResp.data[0]['list'];
        for (int i = 0; i < menu.length; i++) {
          menuModel.add(MenuModel.fromJson(menu[i]));
        }
        print(menuModel);
        pageState = PageState.Success;
      }
      notifyListeners();
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      pageState = PageState.ConnectivityError;
      notifyListeners();
      return false;
    }
  }

  getCreateOrder(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.create_order,
            data: params, showLoading: showLoading)
        .catchError((error) {
      // print(error.toString());
      // if (error is MyError) {
      //   switch (error.type) {
      //     case 1:
      //       pageState = PageState.ConnectivityError;
      //       break;
      //     case 2:
      //       pageState = PageState.ConnectivityTimeOut;
      //       break;
      //     default:
      //       pageState = PageState.ConnectivityError;
      //       break;
      //   }
      // }
      // notifyListeners();
      return null;
    });
    // menuModel = [];

    if (baseResp != null && baseResp.code == Constant.status_success) {
      if (baseResp.data is Map) {
        return baseResp.data['id'];
      }
      // notifyListeners();

    } else {
      Utils.showToast(baseResp.msg ?? "");
      // pageState = PageState.ConnectivityError;
      // notifyListeners();

    }
    return null;
  }

  /// 根据预定ID获取排菜
  getPlanCookByRid(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.get_plan_cook_by_rid,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      // if (error is MyError) {
      //   switch (error.type) {
      //     case 1:
      //       pageState = PageState.ConnectivityError;
      //       break;
      //     case 2:
      //       pageState = PageState.ConnectivityTimeOut;
      //       break;
      //     default:
      //       pageState = PageState.ConnectivityError;
      //       break;
      //   }
      // }
      // notifyListeners();
      return false;
    });
    // menuModel = [];

    if (baseResp != null && baseResp.code == Constant.status_success) {
      if (baseResp.data is Bool) {
        // planCookByRidSunModel = PlanCookByRidSunModel();

      } else {
        planCookByRidSunModel =
            PlanCookByRidModel.fromJson(baseResp.responseData).data;
        if (planCookByRidSunModel != null) {
          planId = baseResp.data['id'];
        }
      }

      //   pageState = PageState.Empty;
      // } else {
      //   List menu = baseResp.data[0]['list'];
      //   for (int i = 0; i < menu.length; i++) {
      //     menuModel.add(MenuModel.fromJson(menu[i]));
      //   }
      //   print(menuModel);
      //   pageState = PageState.Success;
      // }
      // notifyListeners();
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      // pageState = PageState.ConnectivityError;
      // notifyListeners();
      return false;
    }
  }

  ///添加排菜/套餐

  Future<bool> setPlanCook(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.set_plan_cook,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {}
      return false;
    });

    if (baseResp != null && baseResp.code == Constant.status_success) {
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      return false;
    }
  }

  Future<bool> setPlanCookByReserve(
      BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.set_plan_cook_by_reserve,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {}
      return false;
    });

    if (baseResp != null && baseResp.code == Constant.status_success) {
      if (baseResp.data == 1) {
        return true;
      }
      if (baseResp.data['id'] != null && baseResp.data['id'] != '') {
        planId = baseResp.data['id'];
        return true;
      }
    } else {
      Utils.showToast(baseResp.msg ?? "");
      return false;
    }
  }

  ///删除排菜/套餐列表

  Future<bool> delPlanCook(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.del_plan_cook,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {}
      return false;
    });

    if (baseResp != null && baseResp.code == Constant.status_success) {
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      return false;
    }
  }

  ///排菜/套餐列表

  Future<bool> getPlanCookList(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.get_plan_cook_list,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {}
      return false;
    });

    if (baseResp != null && baseResp.code == Constant.status_success) {
      PlanCookListSunModel planCookListSunModel =
          PlanCookListModel.fromJson(baseResp.responseData).data;
      PlanCookListSunModel planCookListSunModel1 =
          PlanCookListModel.fromJson(baseResp.responseData).data;

      allList = [];

      storeList = List.from(planCookListSunModel.packageList);
      mineList = List.from(planCookListSunModel.plancookList);
      allList.addAll(storeList);
      allList.addAll(mineList);
      storeListTemp = planCookListSunModel1.packageList;
      mineListTemp = planCookListSunModel1.plancookList;
      if (storeList.length == 0) {
        pageStateStore = PageState.Empty;
      } else {
        pageStateStore = PageState.Success;
      }
      if (mineList.length == 0) {
        pageStateMine = PageState.Empty;
      } else {
        pageStateMine = PageState.Success;
      }
      if (allList.length == 0) {
        pageStateHome = PageState.Empty;
      } else {
        pageStateHome = PageState.Success;
      }

      notifyListeners();
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      return false;
    }
  }

  Future<bool> getSellerOften(BuildContext context, Map<String, String> params,
      {showLoading = false}) async {
    BaseResp<dynamic> baseResp = await DioUtil()
        .request<dynamic>(context, Method.get, HttpUrl.get_seller_often,
            data: params, showLoading: showLoading)
        .catchError((error) {
      print(error.toString());
      if (error is MyError) {}
      return false;
    });

    if (baseResp != null && baseResp.code == Constant.status_success) {
      List<SellerOftenSunModel> sellerOftenSunModel =
          SellerOftenModel.fromJson(baseResp.responseData).data;
      List<MenuSunModel> data = [];
      List<MenuSunModel> datatemp = [];
      sellerOftenSunModel.forEach((element) {
        // SellerOftenSunModel
        MenuSunModel menuSunModel = MenuSunModel();
        menuSunModel.id = element.id;
        menuSunModel.name = '${element.pnum}人';
        // menuSunModel.price = element.menuPrice;
        menuSunModel.price = element.price;
        menuSunModel.member_price = element.memberPrice ?? element.price;
        menuSunModel.unit = '份';
        //

        List<MenuModel> cookF = [];
        element.cooklist.forEach((value) {
          MenuModel menuModel = MenuModel();
          menuModel.id = value.classid;
          menuModel.sellerid = element.sellerid;
          menuModel.className = value.className;
          menuModel.classLabel = null;
          menuModel.order = null;
          menuModel.status = '1';
          menuModel.classType = null;
          menuModel.cookbooklist = [];
          value.cooklist.forEach((cook) {
            MenuSunModel cookData = MenuSunModel();
            cookData.id = cook.cookbookid;
            cookData.sellerid = cook.sid;
            cookData.cid = cook.classid;
            cookData.price = cook.price;
            cookData.member_price = cook.memberPrice ?? cook.price;
            cookData.name = cook.name;
            cookData.unit = cook.unit;
            cookData.image = cook.image;
            cookData.amount = cook.amount;

            //  "specid": null,
            //  "practiceid": null,
            // "class_name": "炒菜12",
            // "class_order": "2"
            menuModel.cookbooklist.add(cookData);
          });

          cookF.add(menuModel);
        });

        menuSunModel.cookList = cookF;

        data.add(menuSunModel);
        datatemp.add(menuSunModel);
      });
      print(data);

      sellerOftendata = data;

      sellerOftendataTemp = datatemp;

      // sellerOftendata

      notifyListeners();
      return true;
    } else {
      Utils.showToast(baseResp.msg ?? "");
      return false;
    }
  }
}