package model

import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	"time"

	"github.com/zeromicro/go-zero/core/stores/builder"
	"github.com/zeromicro/go-zero/core/stores/cache"
	"github.com/zeromicro/go-zero/core/stores/sqlc"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"github.com/zeromicro/go-zero/core/stringx"
)

var (
	purPurchaseOrderFieldNames          = builder.RawFieldNames(&PurPurchaseOrder{})
	purPurchaseOrderRows                = strings.Join(purPurchaseOrderFieldNames, ",")
	purPurchaseOrderRowsExpectAutoSet   = strings.Join(stringx.Remove(purPurchaseOrderFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), ",")
	purPurchaseOrderRowsWithPlaceHolder = strings.Join(stringx.Remove(purPurchaseOrderFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), "=?,") + "=?"

	cachePurPurchaseOrderIdPrefix      = "cache:purPurchaseOrder:id:"
	cachePurPurchaseOrderOrderIdPrefix = "cache:purPurchaseOrder:orderId:"
	cachePurPurchaseOrderOrderNoPrefix = "cache:purPurchaseOrder:orderNo:"
)

type (
	purPurchaseOrderModel interface {
		Insert(ctx context.Context, data *PurPurchaseOrder) (sql.Result, error)
		FindOne(ctx context.Context, id int64) (*PurPurchaseOrder, error)
		FindOneByOrderId(ctx context.Context, orderId string) (*PurPurchaseOrder, error)
		FindOneByOrderNo(ctx context.Context, orderNo string) (*PurPurchaseOrder, error)
		Update(ctx context.Context, data *PurPurchaseOrder) error
		Delete(ctx context.Context, id int64) error
	}

	defaultPurPurchaseOrderModel struct {
		sqlc.CachedConn
		table string
	}

	PurPurchaseOrder struct {
		Id             int64          `db:"id"`
		OrderId        string         `db:"order_id"`
		TenantId       string         `db:"tenant_id"`
		OrderNo        string         `db:"order_no"`
		SupplierId     string         `db:"supplier_id"`
		OrderDate      time.Time      `db:"order_date"`
		ContractAmount float64        `db:"contract_amount"`
		ReceivedQty    float64        `db:"received_qty"`
		PaidAmount     float64        `db:"paid_amount"`
		PaymentStatus  int64          `db:"payment_status"`
		ReceiptStatus  int64          `db:"receipt_status"`
		PurchaseBy     string         `db:"purchase_by"`
		Creator        string         `db:"creator"`
		Operator       string         `db:"operator"`
		Status         int64          `db:"status"`
		Remark         sql.NullString `db:"remark"`
		CreatedAt      time.Time      `db:"created_at"`
		UpdatedAt      time.Time      `db:"updated_at"`
	}
)

func newPurPurchaseOrderModel(conn sqlx.SqlConn, c cache.CacheConf, opts ...cache.Option) *defaultPurPurchaseOrderModel {
	return &defaultPurPurchaseOrderModel{
		CachedConn: sqlc.NewConn(conn, c, opts...),
		table:      "`pur_purchase_order`",
	}
}

func (m *defaultPurPurchaseOrderModel) Delete(ctx context.Context, id int64) error {
	data, err := m.FindOne(ctx, id)
	if err != nil {
		return err
	}
	purPurchaseOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderIdPrefix, id)
	purPurchaseOrderOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderIdPrefix, data.OrderId)
	purPurchaseOrderOrderNoKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderNoPrefix, data.OrderNo)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
		return conn.ExecCtx(ctx, query, id)
	}, purPurchaseOrderIdKey, purPurchaseOrderOrderIdKey, purPurchaseOrderOrderNoKey)
	return err
}

func (m *defaultPurPurchaseOrderModel) FindOne(ctx context.Context, id int64) (*PurPurchaseOrder, error) {
	purPurchaseOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderIdPrefix, id)
	var resp PurPurchaseOrder
	err := m.QueryRowCtx(ctx, &resp, purPurchaseOrderIdKey, func(ctx context.Context, conn sqlx.SqlConn, v any) error {
		query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", purPurchaseOrderRows, m.table)
		return conn.QueryRowCtx(ctx, v, query, id)
	})
	switch err {
	case nil:
		return &resp, nil
	case sqlc.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultPurPurchaseOrderModel) FindOneByOrderId(ctx context.Context, orderId string) (*PurPurchaseOrder, error) {
	purPurchaseOrderOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderIdPrefix, orderId)
	var resp PurPurchaseOrder
	err := m.QueryRowIndexCtx(ctx, &resp, purPurchaseOrderOrderIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v any) (i any, e error) {
		query := fmt.Sprintf("select %s from %s where `order_id` = ? limit 1", purPurchaseOrderRows, m.table)
		if err := conn.QueryRowCtx(ctx, &resp, query, orderId); err != nil {
			return nil, err
		}
		return resp.Id, nil
	}, m.queryPrimary)
	switch err {
	case nil:
		return &resp, nil
	case sqlc.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultPurPurchaseOrderModel) FindOneByOrderNo(ctx context.Context, orderNo string) (*PurPurchaseOrder, error) {
	purPurchaseOrderOrderNoKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderNoPrefix, orderNo)
	var resp PurPurchaseOrder
	err := m.QueryRowIndexCtx(ctx, &resp, purPurchaseOrderOrderNoKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v any) (i any, e error) {
		query := fmt.Sprintf("select %s from %s where `order_no` = ? limit 1", purPurchaseOrderRows, m.table)
		if err := conn.QueryRowCtx(ctx, &resp, query, orderNo); err != nil {
			return nil, err
		}
		return resp.Id, nil
	}, m.queryPrimary)
	switch err {
	case nil:
		return &resp, nil
	case sqlc.ErrNotFound:
		return nil, ErrNotFound
	default:
		return nil, err
	}
}

func (m *defaultPurPurchaseOrderModel) Insert(ctx context.Context, data *PurPurchaseOrder) (sql.Result, error) {
	purPurchaseOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderIdPrefix, data.Id)
	purPurchaseOrderOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderIdPrefix, data.OrderId)
	purPurchaseOrderOrderNoKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderNoPrefix, data.OrderNo)
	ret, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, purPurchaseOrderRowsExpectAutoSet)
		return conn.ExecCtx(ctx, query,
			data.OrderId, data.TenantId, data.OrderNo, data.SupplierId, data.OrderDate,
			data.ContractAmount, data.ReceivedQty, data.PaidAmount, data.PaymentStatus, data.ReceiptStatus,
			data.PurchaseBy, data.Creator, data.Operator, data.Status, data.Remark)
	}, purPurchaseOrderIdKey, purPurchaseOrderOrderIdKey, purPurchaseOrderOrderNoKey)
	return ret, err
}

func (m *defaultPurPurchaseOrderModel) Update(ctx context.Context, newData *PurPurchaseOrder) error {
	data, err := m.FindOne(ctx, newData.Id)
	if err != nil {
		return err
	}
	purPurchaseOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderIdPrefix, data.Id)
	purPurchaseOrderOrderIdKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderIdPrefix, data.OrderId)
	purPurchaseOrderOrderNoKey := fmt.Sprintf("%s%v", cachePurPurchaseOrderOrderNoPrefix, data.OrderNo)
	_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, purPurchaseOrderRowsWithPlaceHolder)
		return conn.ExecCtx(ctx, query,
			newData.OrderId, newData.TenantId, newData.OrderNo, newData.SupplierId, newData.OrderDate,
			newData.ContractAmount, newData.ReceivedQty, newData.PaidAmount, newData.PaymentStatus, newData.ReceiptStatus,
			newData.PurchaseBy, newData.Creator, newData.Operator, newData.Status, newData.Remark, newData.Id)
	}, purPurchaseOrderIdKey, purPurchaseOrderOrderIdKey, purPurchaseOrderOrderNoKey)
	return err
}

func (m *defaultPurPurchaseOrderModel) formatPrimary(primary any) string {
	return fmt.Sprintf("%s%v", cachePurPurchaseOrderIdPrefix, primary)
}

func (m *defaultPurPurchaseOrderModel) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary any) error {
	query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", purPurchaseOrderRows, m.table)
	return conn.QueryRowCtx(ctx, v, query, primary)
}

func (m *defaultPurPurchaseOrderModel) tableName() string {
	return m.table
}