package app

import (
	"context"

	v1 "git.5iot.com/iotlcm-public/iotlcm-app/api/app/v1"
	"git.5iot.com/iotlcm-public/iotlcm-app/internal/service"
)

func (c *ControllerV1) PublicQueryCard(ctx context.Context, req *v1.PublicQueryCardReq) (res *v1.PublicQueryCardRes, err error) {
	card, err := service.AppCard().PublicQuery(ctx, &req.AppCardQueryParam)
	if err != nil {
		return nil, err
	}
	return &v1.PublicQueryCardRes{Card: card}, nil
}

func (c *ControllerV1) RecognizeCard(ctx context.Context, req *v1.RecognizeCardReq) (res *v1.RecognizeCardRes, err error) {
	result, err := service.AppCard().RecognizeCard(ctx)
	if err != nil {
		return nil, err
	}
	return &v1.RecognizeCardRes{AppCardRecognitionModel: result}, nil
}

func (c *ControllerV1) CardList(ctx context.Context, req *v1.CardListReq) (res *v1.CardListRes, err error) {
	items, total, err := service.AppCard().List(ctx, &req.AppCardListParam)
	if err != nil {
		return nil, err
	}
	hasMore := len(items) >= req.PageSize
	if req.IncludeTotal == nil || *req.IncludeTotal {
		hasMore = req.Page*req.PageSize < total
	}
	return &v1.CardListRes{Items: items, Total: total, HasMore: hasMore}, nil
}

func (c *ControllerV1) PackageList(ctx context.Context, req *v1.PackageListReq) (res *v1.PackageListRes, err error) {
	items, total, err := service.AppCard().PackageList(ctx, &req.AppPackageListParam)
	if err != nil {
		return nil, err
	}
	return &v1.PackageListRes{Items: items, Total: total}, nil
}

func (c *ControllerV1) PublicPackageDetail(ctx context.Context, req *v1.PublicPackageDetailReq) (res *v1.PublicPackageDetailRes, err error) {
	pkg, err := service.AppCard().PublicPackageDetail(ctx, &req.AppPackagePublicDetailParam)
	if err != nil {
		return nil, err
	}
	return &v1.PublicPackageDetailRes{Package: pkg}, nil
}

func (c *ControllerV1) CardDetail(ctx context.Context, req *v1.CardDetailReq) (res *v1.CardDetailRes, err error) {
	card, err := service.AppCard().Detail(ctx, &req.AppCardDetailParam)
	if err != nil {
		return nil, err
	}
	return &v1.CardDetailRes{Card: card}, nil
}

func (c *ControllerV1) BindCard(ctx context.Context, req *v1.BindCardReq) (res *v1.BindCardRes, err error) {
	card, err := service.AppCard().Bind(ctx, &req.AppCardBindParam)
	if err != nil {
		return nil, err
	}
	return &v1.BindCardRes{Card: card}, nil
}

func (c *ControllerV1) RestartCard(ctx context.Context, req *v1.RestartCardReq) (res *v1.RestartCardRes, err error) {
	restart, err := service.AppCard().Restart(ctx, &req.AppCardRestartParam)
	if err != nil {
		return nil, err
	}
	return &v1.RestartCardRes{AppCardRestartModel: restart}, nil
}

func (c *ControllerV1) StopCard(ctx context.Context, req *v1.StopCardReq) (res *v1.StopCardRes, err error) {
	stop, err := service.AppCard().Stop(ctx, &req.AppCardRestartParam)
	if err != nil {
		return nil, err
	}
	return &v1.StopCardRes{AppCardLifecycleModel: stop}, nil
}

func (c *ControllerV1) StartCard(ctx context.Context, req *v1.StartCardReq) (res *v1.StartCardRes, err error) {
	start, err := service.AppCard().Start(ctx, &req.AppCardRestartParam)
	if err != nil {
		return nil, err
	}
	return &v1.StartCardRes{AppCardLifecycleModel: start}, nil
}

func (c *ControllerV1) LifecycleBatchSubmit(ctx context.Context, req *v1.LifecycleBatchSubmitReq) (res *v1.LifecycleBatchSubmitRes, err error) {
	submit, err := service.AppCard().LifecycleBatchSubmit(ctx, &req.AppCardLifecycleParam)
	if err != nil {
		return nil, err
	}
	return &v1.LifecycleBatchSubmitRes{AppCardLifecycleModel: submit}, nil
}

func (c *ControllerV1) LifecycleBatchStatus(ctx context.Context, req *v1.LifecycleBatchStatusReq) (res *v1.LifecycleBatchStatusRes, err error) {
	status, err := service.AppCard().LifecycleBatchStatus(ctx, &req.AppCardLifecycleStatusParam)
	if err != nil {
		return nil, err
	}
	return &v1.LifecycleBatchStatusRes{AppCardLifecycleModel: status}, nil
}

func (c *ControllerV1) RenewPrepare(ctx context.Context, req *v1.RenewPrepareReq) (res *v1.RenewPrepareRes, err error) {
	prepare, err := service.AppCard().RenewPrepare(ctx, &req.AppCardRenewPrepareParam)
	if err != nil {
		return nil, err
	}
	return &v1.RenewPrepareRes{AppCardRenewPrepareModel: prepare}, nil
}

func (c *ControllerV1) RenewBatchPrepare(ctx context.Context, req *v1.RenewBatchPrepareReq) (res *v1.RenewBatchPrepareRes, err error) {
	prepare, err := service.AppCard().RenewBatchPrepare(ctx, &req.AppCardRenewBatchPrepareParam)
	if err != nil {
		return nil, err
	}
	return &v1.RenewBatchPrepareRes{AppCardRenewPrepareModel: prepare}, nil
}

func (c *ControllerV1) RenewSubmit(ctx context.Context, req *v1.RenewSubmitReq) (res *v1.RenewSubmitRes, err error) {
	submit, err := service.AppCard().RenewSubmit(ctx, &req.AppCardRenewSubmitParam)
	if err != nil {
		return nil, err
	}
	return &v1.RenewSubmitRes{AppCardRenewSubmitModel: submit}, nil
}

func (c *ControllerV1) RenewBatchSubmit(ctx context.Context, req *v1.RenewBatchSubmitReq) (res *v1.RenewBatchSubmitRes, err error) {
	submit, err := service.AppCard().RenewBatchSubmit(ctx, &req.AppCardRenewBatchSubmitParam)
	if err != nil {
		return nil, err
	}
	return &v1.RenewBatchSubmitRes{AppCardRenewSubmitModel: submit}, nil
}

func (c *ControllerV1) AllocateTargets(ctx context.Context, req *v1.AllocateTargetsReq) (res *v1.AllocateTargetsRes, err error) {
	items, total, err := service.AppCard().AllocateTargets(ctx, &req.AppCardAllocateTargetListParam)
	if err != nil {
		return nil, err
	}
	return &v1.AllocateTargetsRes{Items: items, Total: total}, nil
}

func (c *ControllerV1) AllocateBatchPrepare(ctx context.Context, req *v1.AllocateBatchPrepareReq) (res *v1.AllocateBatchPrepareRes, err error) {
	prepare, err := service.AppCard().AllocateBatchPrepare(ctx, &req.AppCardAllocateBatchPrepareParam)
	if err != nil {
		return nil, err
	}
	return &v1.AllocateBatchPrepareRes{AppCardAllocateBatchModel: prepare}, nil
}

func (c *ControllerV1) AllocateBatchSubmit(ctx context.Context, req *v1.AllocateBatchSubmitReq) (res *v1.AllocateBatchSubmitRes, err error) {
	submit, err := service.AppCard().AllocateBatchSubmit(ctx, &req.AppCardAllocateBatchSubmitParam)
	if err != nil {
		return nil, err
	}
	return &v1.AllocateBatchSubmitRes{AppCardAllocateBatchModel: submit}, nil
}

func (c *ControllerV1) ChangePrepare(ctx context.Context, req *v1.ChangePrepareReq) (res *v1.ChangePrepareRes, err error) {
	prepare, err := service.AppCard().ChangePrepare(ctx, &req.AppCardChangePrepareParam)
	if err != nil {
		return nil, err
	}
	return &v1.ChangePrepareRes{AppCardChangePrepareModel: prepare}, nil
}

func (c *ControllerV1) ChangeSubmit(ctx context.Context, req *v1.ChangeSubmitReq) (res *v1.ChangeSubmitRes, err error) {
	submit, err := service.AppCard().ChangeSubmit(ctx, &req.AppCardChangeSubmitParam)
	if err != nil {
		return nil, err
	}
	return &v1.ChangeSubmitRes{AppCardChangeSubmitModel: submit}, nil
}