import { IBaseOrder, ICart, IOrder, IOrderCart, IProduct, IProductsState, IProductInfo, ICatProd } from 'model'

import { Api } from '@api'
import { serv_constants } from '@src/store/Modules/serv_constants'
import * as Types from '@src/store/Api/ApiTypes'
import { static_data } from '@src/db/static_data'
import { shared_consts } from '@src/common/shared_vuejs'
import { tools } from '@store/Modules/tools'
import { defineStore } from 'pinia'
import { useUserStore } from '@store/UserStore'
import { toolsext } from '@store/Modules/toolsext'
import { useGlobalStore } from './globalStore'
import { ref } from 'vue'

import translate from '@src/globalroutines/util'

function getRecordProductInfoEmpty(): IProductInfo {
  return {
    code: '',
    name: '',
    description: '',
    department: '',
    catprods: [],
    color: '',
    size: '',
    weight: 0,
    unit: 0,
    stars: 0,
    date: tools.getDateNow(),
    icon: '',
    img: '',
  }
}

function getRecordProductEmpty() {
  return {
    active: false,
    productInfo: {
      img: '', code: '', name: '',

    },
    storehouses: [], scontisticas: [],
    price: 0, stockQty: 0, bookableQty: 0, gasordines: [],
    idGasordines: [], minBuyQty: 1, maxBookableQty: 0,
  }
}

export const useProducts = defineStore('Products', {
  state: (): IProductsState => ({
    products: [],
    cart: { items: [], totalPrice: 0, totalQty: 0, userId: '' },
    orders: [],
    catprods: [],
    productInfos: [],
  }),

  getters: {
    getCatProds: (state: IProductsState) => (): ICatProd[] => {
      return state.catprods
    },

    getNumProdTot: (state: IProductsState) => (): number => {
      return state.products.length
    },

    getProducts: (state: IProductsState) => (cosa?: number): IProduct[] => {
      if (!!cosa) {
        return state.products.filter((rec: IProduct) => {
          const hasGasOrdines = rec.idGasordines && rec.idGasordines.length > 0;

          if ((cosa === shared_consts.PROD.GAS && hasGasOrdines) ||
            (cosa === shared_consts.PROD.BOTTEGA && ((!hasGasOrdines || (hasGasOrdines && rec.idGasordines?.length === 0))))) {
            return true;
          }

          return false;
        });
      } else {
        return state.products;
      }
    },

    updateDataProduct: (state: IProductsState) => (res: any) => {
      if (res && res.data.product) {
        // Update product from server
        const indelem = state.products.findIndex((prod: IProduct) => prod._id === res.data.product._id)
        if (indelem >= 0) {
          state.products[indelem] = { ...res.data.product }

          /*if (!res.data.orders) {
            // aggiorna anche tutti i product negli ordini !
            let ordcart: IOrderCart
            for (ordcart of state.orders) {
              for (const item of ordcart.items!) {
                if (item.order.idProduct === res.data.product.idProduct)
                  item.order.product = res.data.product
              }
            }
          }*/
        }
      }
      if (res && res.data.orders) {
        state.orders = res.data.orders
      }

      if (res && res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
        state.cart = res.data.cart
      }

    },


    getProductById: (state: IProductsState) => (id: string): IProduct => {
      const prod = state.products.find((prod: IProduct) => prod._id === id)
      return prod ? prod : getRecordProductEmpty()
    },

    getProductByCode: (state: IProductsState) => (code: string): IProduct => {
      if (!code) {
        return getRecordProductEmpty()
      }

      const prod = state.products.find((prod: IProduct) => {
        if (prod.productInfo.code === code)
          return prod
        else
          return null
      })
      return prod ? prod : getRecordProductEmpty()
    },

    getCart: (state: IProductsState) => (): ICart => {
      return state.cart
    },

    getOrdersAllCart: (state: IProductsState) => (): IOrderCart[] => {
      return state.orders
    },

    getNumOrders: (state: IProductsState) => (): number => {
      return state.orders.length
    },

    getOrdersCart: (state: IProductsState) => (tipoord: number): IOrderCart[] | undefined => {
      console.log('state.orders', state.orders)
      if (tipoord === shared_consts.OrderStat.IN_CORSO.value)
        return state.orders.filter((rec: IOrderCart) => (rec.status ? rec.status : 0) <= shared_consts.OrderStatus.CHECKOUT_SENT)
      else if (tipoord === shared_consts.OrderStat.CONFERMATI.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.ORDER_CONFIRMED)
      else if (tipoord === shared_consts.OrderStat.PAGATI.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.PAYED)
      else if (tipoord === shared_consts.OrderStat.DELIVERED.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.DELIVERED)
      else if (tipoord === shared_consts.OrderStat.SHIPPED.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.SHIPPED)
      else if (tipoord === shared_consts.OrderStat.RECEIVED.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.RECEIVED)
      else if (tipoord === shared_consts.OrderStat.COMPLETATI.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.COMPLETED)
      else if (tipoord === shared_consts.OrderStat.CANCELLATI.value)
        return state.orders.filter((rec: IOrderCart) => rec.status === shared_consts.OrderStatus.CANCELED)
    },

    existProductInCart: (state: IProductsState) => (idproduct: string): boolean => {
      // console.log('.cart.items', this.cart.items)
      if (state.cart.items) {
        const ris = state.cart.items.filter((item: IBaseOrder) => item.order.idProduct === idproduct).reduce((sum, rec) => sum + 1, 0)
        return ris > 0
      }
      return false
    },
    getOrderProductInCart: (state: IProductsState) => (idproduct: string): IOrder | null => {
      // console.log('.cart.items', this.cart.items)
      if (state.cart.items) {
        const ris = state.cart.items.find((item: IBaseOrder) => item.order.idProduct === idproduct)
        return ris ? ris.order : null
      }
      return null
    },

    getOrderProductInOrdersCart: (state: IProductsState) => (idordercart: string, idproduct: string): IOrder | null => {
      // console.log('.cart.items', this.cart.items)
      if (state.orders) {
        const orderscart = state.orders.find((rec: IOrderCart) => rec._id === idordercart)
        if (orderscart) {
          const ris = orderscart.items!.find((item: IBaseOrder) => item.order.idProduct === idproduct)
          return ris ? ris.order : null
        }
      }
      return null
    },

    getSumQtyPreOrderInOrdersCart: (state: IProductsState) => (idproduct: string): number => {
      let totalQuantity = 0;

      if (state.orders) {
        const orderscart = state.orders
        if (orderscart) {
          for (const myord of orderscart) {
            if (myord.items) {
              for (const item of myord.items) {
                if (item.order) {
                  if ((item.order.idProduct === idproduct) && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)) {
                    totalQuantity += (item.order.quantitypreordered) || 0;
                  }
                }
              }
            }
          }
        }
      }
      return totalQuantity
    },

    getSumQtyOrderProductInOrdersCart: (state: IProductsState) => (idproduct: string): number => {
      let totalQuantity = 0;

      if (state.orders) {
        const orderscart = state.orders
        if (orderscart) {
          for (const myord of orderscart) {
            if (myord.items) {
              for (const item of myord.items) {
                if (item.order) {
                  if ((item.order.idProduct === idproduct) && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)) {
                    totalQuantity += (item.order.quantity) || 0;
                  }
                }
              }
            }
          }
        }
      }
      return totalQuantity
    },

    getOrdersCartByIdProduct: (state: IProductsState) => (idproduct: string): IOrderCart[] | [] => {
      try {
        if (state.orders) {
          const ris = state.orders.filter((ordercart: IOrderCart) => {
            return ordercart.items!.some(item => {
              if (item.order)
                return (item.order.idProduct === idproduct)
                  && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)
            })
          })
          // console.log('Ordini ', ris)
          return ris ? ris : []
        }
      } catch (e) {
        console.error('Err', e)
      }
      return []
    },

    getOrdersCartInAttesaByIdProduct: (state: IProductsState) => (idproduct: string): IOrderCart[] | [] => {
      try {
        if (state.orders) {
          const ris = state.orders.filter((ordercart: IOrderCart) => {
            return ordercart.items!.some(item => {
              if (item.order)
                return (item.order.idProduct === idproduct)
                  && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)
            })
          })
          // console.log('Ordini ', ris)
          return ris ? ris : []
        }
      } catch (e) {
        console.error('Err', e)
      }
      return []
    },


    getRecordEmpty: (state: IProductsState) => (): IProduct => {

      const tomorrow = tools.getDateNow()
      tomorrow.setDate(tomorrow.getDate() + 1)

      return {
        productInfo: getRecordProductInfoEmpty(),
        // _id: tools.getDateNow().toISOString(),  // Create NEW
        active: false,
        idProducer: '',
        idStorehouses: [],
        idGasordines: [],
        idScontisticas: [],
        scontisticas: [],
        gasordines: [],
        idProvider: '',
        producer: {},
        storehouses: [],
        provider: {},
        price: 0.0,
        quantityAvailable: 0,
        bookableAvailableQty: 0,
        stockQty: 0,
        minBuyQty: 1,
        maxBookableQty: 0,
        bookableQty: 0,
        canBeShipped: false,
        QuantitaOrdinateInAttesa: 0,
        QuantitaPrenotateInAttesa: 0,
        canBeBuyOnline: false,
      }
    },

  },

  actions: {

    createOrderByProduct(product: IProduct, order: IOrder): IOrder {
      const userStore = useUserStore()
      const myorder: IOrder = {
        userId: userStore.my._id,
        idapp: process.env.APP_ID,
        status: shared_consts.OrderStatus.IN_CART,
        TotalPriceProduct: 0,
        idProduct: product._id,
        product,  // Copia tutto l'oggetto Product ! 

        // Ordine:
        price: product.price,
        after_price: product.after_price,
        quantity: order.quantity,
        quantitypreordered: order.quantitypreordered,
        idStorehouse: order.idStorehouse,
      }

      return myorder
    },

    initcat() {

      // rec.userId = userStore.my._id

      return this.getRecordEmpty()

    },

    /*resetProducts() {
      const arrprod = [...this.products]
      this.products = []
      this.products = [...arrprod]
    },*/

    async loadProducts() {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      // console.log('loadProducts')

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      console.log('getProducts', 'userid=', userStore.my._id)

      // if (userStore.my._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null

      console.log('Ottieni Prodotti')
      ris = await Api.SendReq('/products', 'POST', { userId: userStore.my._id })
        .then((res) => {
          console.log('Prodotti scaricati')
          if (res.data.products) {
            this.products = res.data.products
          } else {
            this.products = []
          }

          if (res.data.orders) {
            this.orders = res.data.orders
          } else {
            this.orders = []
          }

          if (process.env.DEBUG === '1') {
          }

          return res
        })
        .catch((error) => {
          console.log('error getProducts', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async loadProduct({ code }: { code: any }) {

      console.log('loadProduct', code)
      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      console.log('getProduct', 'code', code)

      // if (userStore.my._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null

      ris = await Api.SendReq('/products/' + code, 'POST', { code })
        .then((res) => {
          console.log('product', res.data.product)
          if (res.data.product) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.updateDataProduct(res)
            return res.data.product
          } else {
            return null
          }
        })
        .catch((error) => {
          console.log('error getProduct', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },

    async loadOrders() {

      console.log('loadOrders')
      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      // if (userStore.my._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null

      ris = await Api.SendReq('/cart/' + userStore.my._id, 'GET', null)
        .then((res) => {
          if (res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' }
          }

          this.updateDataProduct(res)

          return res
        })
        .catch((error) => {
          console.log('error loadOrders', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')
      return ris
    },


    async removeFromCart({ order }: { order: IOrder }) {

      const userStore = useUserStore()

      return Api.SendReq('/cart/' + userStore.my._id, 'DELETE', { orderId: order._id })
        .then((res) => {
          this.updateDataProduct(res)

          return res
        })
    },

    async addToCart({ product, order, addqty }: { product: IProduct, order: IOrder, addqty: boolean }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let neworder = null;

      // Controlla se esiste già nel carrello, allora semplicemente aggiungerò la quantità:
      if (this.existProductInCart(product._id)) {
        const ordcart = this.getOrderProductInCart(product._id)
        if (ordcart) {

          if (!addqty && ((ordcart.quantity + ordcart.quantitypreordered) === 1)) {
            // sto per rimuovere l'ultimo pezzo, quindi cancello direttamente
            const risrem = await this.removeFromCart({ order: ordcart })

            if (risrem) {
              order.quantity = 0
              order.quantitypreordered = 0
              return true
            } else {
              return false
            }
          }

          return await this.addSubQtyToItem({
            addqty,
            subqty: !addqty,
            order: ordcart,
          }).then((res: any) => {
            if (res && res.msgerr) {
              return res;
            } else if (res && res.risult) {
              order.quantity = res.myord.quantity
              order.quantitypreordered = res.myord.quantitypreordered
            }
            return res;
          })
        }
      } else {
        if (this.isQtyAvailableByProduct(product)) {
          order.quantity = product.minBuyQty | 1
          order.quantitypreordered = 0
        } else {
          if (this.isInPreorderByProduct(product)) {
            order.quantitypreordered = product.minBuyQty | 1
            order.quantity = 0
          }
        }

        if (!order.idStorehouse) {
          if (product.storehouses.length === 1) {
            order.idStorehouse = product.storehouses[0]._id
          } else {
            order.idStorehouse = globalStore.storehouses ? globalStore.storehouses[0]._id : ''
          }
        }

        if (order.idStorehouse) {
          neworder = this.createOrderByProduct(product, order)
        }
      }

      // if (neworder && !neworder.idStorehouse)
      //   return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, 'Nessuno Store')

      console.log('addToCart', 'userid=', userStore.my._id, neworder)

      let ris = null

      ris = await Api.SendReq('/cart/' + userStore.my._id, 'POST', { order: neworder })
        .then((res) => {
          if (res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' }
          }
          this.updateDataProduct(res)

          return { risult: !!res, myord: res.data.myord, msgerr: res.data.msgerr }
        })
        .catch((error) => {
          console.log('error addToCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async addSubQtyToItem({ addqty, subqty, order }: { addqty: boolean, subqty: boolean, order: IOrder }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      // console.log('addSubQtyToItem', 'userid=', userStore.my._id, order)

      let ris = null

      ris = await Api.SendReq('/cart/' + userStore.my._id, 'POST', { addqty, subqty, order })
        .then((res: any) => {
          this.updateDataProduct(res)

          return { risult: !!res, myord: res.data.myord, msgerr: res.msgerr }
        })
        .catch((error) => {
          console.log('error addSubQtyToItem', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async CreateOrdersCart({ cart_id, status, note }: { cart_id: string, status: number, note: string }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/' + userStore.my._id + '/createorderscart', 'POST', { cart_id, status, note })
        .then((res) => {

          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            // Cancella il Carrello, ho creato l'ordine !
            this.cart = {}
          }

          this.updateDataProduct(res)

          return res.data.recOrderCart
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },

    async UpdateStatusCart({ ordercart_id, status }: { ordercart_id: string, status: number }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/updatestatuscart', 'POST', { ordercart_id, status })
        .then((res) => {

          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            this.cart = {}
          }
          this.updateDataProduct(res)

          return res.data.status
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },

    async UpdateOrderCartStatus({ order_id, status }: { order_id: string, status: number }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/' + userStore.my._id + '/ordercartstatus', 'POST', { order_id, status })
        .then((res) => {

          this.updateDataProduct(res)

          return res.data.status

        })
        .catch((error) => {
          console.log('error UpdateOrderCartStatus', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },
    async addtoCartBase({ $q, t, id, order, addqty }: { $q: any, t: any, id: string, order: IOrder, addqty: boolean }) {
      let product = this.getProductById(id)

      return await this.addToCart({ product, order, addqty })
        .then((ris) => {
          if (ris && ris.msgerr) {
            tools.showNegativeNotif($q, ris.msgerr)
          } else {
            let strprod = t('ecomm.prodotto')

            let msg = ''
            console.log('ris', ris)
            if (ris && ris.myord == null) {
              msg = t('ecomm.prodotto_tolto')
              tools.showNotif($q, msg)
              return
            }
            if (ris === null || ris.myord == null) {
              msg = t('ecomm.error_cart')
              tools.showNegativeNotif($q, msg)
              return
            } else {

              let qta = ris.myord.quantity + ris.myord.quantitypreordered
              if (qta > 1 || qta === 0)
                strprod = t('ecomm.prodotti')

              if (qta > 0) {
                msg = t('ecomm.prod_sul_carrello', { strprod, qty: qta })
              }

            }
            if (ris === null || ris.myord.quantity === 0)
              tools.showNotif($q, msg)
            else
              tools.showPositiveNotif($q, msg)


          }
          //updateproduct()

          return ris
        })
    },

    getQuantityByOrder($t: any, order: IOrder): string {
      let mystr = '';
      if (order.quantity > 0) {
        mystr += order.quantity
      }
      if ((order.quantitypreordered > 0) && (order.quantity > 0)) {
        mystr += ' ' + $t('ecomm.available')
        mystr += ' + '
      }
      if (order.quantitypreordered > 0) {
        mystr += ' ' + order.quantitypreordered + ' ' + $t('ecomm.preord');
      }
      return mystr
    },

    isQtyAvailableByProduct(product: IProduct): boolean {
      if (product) {
        return (product.quantityAvailable! > 0)
      }
      return false;
    },

    isInPreorderByProduct(product: IProduct): boolean {
      if (product) {
        return (product.bookableAvailableQty! > 0)
      }
      return false;
    },

    isQtyAvailableByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isQtyAvailableByProduct(order.product)
      }
      return false;
    },

    isInPreorderByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isInPreorderByProduct(order.product)
      }
      return false;
    },

    getSingleGasordine(order: IOrder, short: boolean): string {
      try {
        const mygas = order.gasordine
        if (mygas) {
          if (short)
            return mygas.name!
          else
            return mygas.name + ' (' + mygas.city + ') ' + translate('gas.dataora_chiusura_ordini') + ': ' + tools.getstrDateShort(mygas.dataora_chiusura_ordini)
              + ' ' + translate('gas.dataora_ritiro') + ': ' + tools.getstrDateShort(mygas.dataora_ritiro)
        } else
          return ''
      } catch (e) {
        return ''
      }
    },

    getQtyAvailable(myproduct: IProduct): number {
      let qty = myproduct.quantityAvailable!
      return qty
    },

    getQtyBookableAvailable(myproduct: IProduct): number {
      let qty = myproduct.bookableAvailableQty!
      return qty
    },

    enableSubQty(myorder: IOrder): boolean {
      let qty = myorder.quantity + myorder.quantitypreordered
      return qty ? qty > 0 : false
    },

    enableAddQty(myorder: IOrder, myproduct: IProduct): boolean {
      const globalStore = useGlobalStore()
      if (globalStore.site.ecomm && globalStore.site.ecomm.enablePreOrders) {
        return (this.getQtyBookableAvailable(myproduct) > 0
          && (myproduct.maxBookableQty === 0
            || (myorder.quantitypreordered + 1 < myproduct.maxBookableQty))
        )
          || (this.getQtyAvailable(myproduct) > 0)
          && (myproduct.maxBookableQty === 0
            || (myorder.quantity + 1 < myproduct.maxBookableQty))

      } else {
        return (this.getQtyAvailable(myproduct) > 0)
          && (myproduct.maxBookableQty === 0
            || (myorder.quantity + 1 < myproduct.maxBookableQty))
      }

    },

    qtaNextAdd(myorder: IOrder, myproduct: IProduct): number {
      let step = 1
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === 0)
          step = myproduct.minBuyQty | 1
      } else {
        if (myorder.quantitypreordered === 0)
          step = myproduct.minBuyQty | 1
      }

      return step
    },

    qtaNextSub(myorder: IOrder, myproduct: IProduct) {
      let step = 1
      let minqta = myproduct.minBuyQty | 1
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === minqta)
          step = minqta
      } else {
        if (myorder.quantitypreordered === minqta)
          step = minqta
      }

      return step
    },

  },



})