package billing

import (
	"encoding/json"
	"sync"
	"time"

	"cloud.o-forge.io/core/oc-lib/dbs"
	"cloud.o-forge.io/core/oc-lib/models/billing/subscription"
	"cloud.o-forge.io/core/oc-lib/models/common/enum"
	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
	"cloud.o-forge.io/core/oc-lib/models/order"
	"cloud.o-forge.io/core/oc-lib/models/peer"
	"cloud.o-forge.io/core/oc-lib/models/resources"
	"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
	"cloud.o-forge.io/core/oc-lib/models/utils"
	"cloud.o-forge.io/core/oc-lib/tools"
	"github.com/google/uuid"
)

type Bill struct {
	utils.AbstractObject
	OrderID   string                `json:"order_id" bson:"order_id" validate:"required"`
	Status    enum.CompletionStatus `json:"status" bson:"status" default:"0"`
	SubOrders map[string]*PeerOrder `json:"sub_orders" bson:"sub_orders"`
	Total     float64               `json:"total" bson:"total" validate:"required"`
}

func (ri *Bill) Extend(typ ...string) map[string][]tools.DataType {
	ext := ri.AbstractObject.Extend(typ...)
	for _, t := range typ {
		switch t {
		case "order":
			if _, ok := ext[t]; !ok {
				ext[t] = []tools.DataType{}
			}
			ext[t] = append(ext[t], tools.ORDER)
		}
	}
	return ext
}

// IsFullySettled retourne vrai quand chaque ligne de chaque peer-order est réglée.
func (b *Bill) IsFullySettled() bool {
	for _, po := range b.SubOrders {
		for _, item := range po.Items {
			if !item.Settled {
				return false
			}
		}
	}
	return true
}

// SettledTotal retourne le montant total des lignes déjà réglées.
func (b *Bill) SettledTotal() float64 {
	total := 0.0
	for _, po := range b.SubOrders {
		for _, item := range po.Items {
			if item.Settled {
				total += item.UnitPriceHT * float64(item.Quantity)
			}
		}
	}
	return total
}

// MarkItemSettled marque une ligne comme réglée d'après son itemID
// et propage le statut PAID sur le PeerOrder si toutes ses lignes sont réglées.
func (b *Bill) MarkItemSettled(itemID string) bool {
	now := time.Now().UTC()
	for _, po := range b.SubOrders {
		for _, item := range po.Items {
			if item.ItemID == itemID {
				item.Settled = true
				item.SettledAt = &now
				// propage le statut PAID si toutes les lignes du peer sont réglées
				if po.IsFullySettled() {
					po.Status = enum.PAID
				}
				return true
			}
		}
	}
	return false
}

func GenerateBill(ord *order.Order, request *tools.APIRequest) (*Bill, error) {
	return &Bill{
		AbstractObject: utils.AbstractObject{
			Name:    "bill_" + request.PeerID + "_" + time.Now().UTC().Format("2006-01-02T15:04:05"),
			IsDraft: false,
		},
		OrderID: ord.UUID,
		Status:  enum.PENDING,
	}, nil
}

// DraftFirstBill crée le premier brouillon de facture pour un order.
// Règle :
//   - Calcul total indépendant du mode de paiement (photo du coût réel).
//   - Les purchases sont toujours BILL_ONCE / PAY_ONCE → réglées immédiatement.
//   - Les bookings avec BillingStrategy != BILL_ONCE génèrent des Subscription.
//   - Chaque ligne reçoit un ItemID unique pour le suivi de règlement.
func DraftFirstBill(ord *order.Order, request *tools.APIRequest) (*Bill, error) {
	peers := map[string][]*PeerItemOrder{}

	// Purchases : facturation immédiate, pas de subscription
	for _, p := range ord.Purchases {
		if _, ok := peers[p.DestPeerID]; !ok {
			peers[p.DestPeerID] = []*PeerItemOrder{}
		}
		peers[p.DestPeerID] = append(peers[p.DestPeerID], &PeerItemOrder{
			ItemID:          uuid.New().String(),
			ResourceType:    p.ResourceType,
			Purchase:        p,
			Item:            p.PricedItem,
			Quantity:        1,
			BillingStrategy: pricing.BILL_ONCE,
			PaymentType:     pricing.PAY_ONCE,
		})
	}

	// Bookings : exclure les ressources déjà achetées (purchase_resource existant)
	purchasedIDs := map[string]bool{}
	for _, p := range ord.Purchases {
		purchasedIDs[p.ResourceID] = true
	}
	for _, b := range ord.Bookings {
		if purchasedIDs[b.ResourceID] {
			continue
		}
		if _, ok := peers[b.DestPeerID]; !ok {
			peers[b.DestPeerID] = []*PeerItemOrder{}
		}
		peers[b.DestPeerID] = append(peers[b.DestPeerID], &PeerItemOrder{
			ItemID:          uuid.New().String(),
			ResourceType:    b.ResourceType,
			Quantity:        1,
			Item:            b.PricedItem,
			BillingStrategy: b.BillingStrategy,
			PaymentType:     b.PaymentType,
		})
	}

	// Résolution des adresses de facturation peer
	peerOrders := map[string]*PeerOrder{}
	for peerID, items := range peers {
		pr, _, err := peer.NewAccessor(request).LoadOne(peerID)
		if err != nil {
			return nil, err
		}
		peerOrders[peerID] = &PeerOrder{
			PeerID:         peerID,
			BillingAddress: pr.(*peer.Peer).WalletAddress,
			Items:          items,
		}
	}

	bill := &Bill{
		AbstractObject: utils.AbstractObject{
			Name:    "bill_" + request.PeerID + "_" + time.Now().UTC().Format("2006-01-02T15:04:05"),
			IsDraft: true,
		},
		OrderID:   ord.UUID,
		Status:    enum.PENDING,
		SubOrders: peerOrders,
	}

	// 1. Calcul des totaux (indépendant du mode de paiement)
	if _, err := bill.SumUpBill(request); err != nil {
		return bill, err
	}

	// 2. Création des subscriptions pour les lignes récurrentes
	subIDs, err := createRecurringSubscriptions(bill, request)
	if err != nil {
		return bill, err
	}

	// 3. Liaison des subscription IDs à l'order pour traçabilité
	if len(subIDs) > 0 {
		ord.SubscriptionIDs = append(ord.SubscriptionIDs, subIDs...)
	}

	// 4. Persistance du brouillon de facture (les UnitPriceHT et SubscriptionID sont déjà set)
	stored, _, err := NewAccessor(request).StoreOne(bill)
	if err != nil {
		return bill, err
	}
	return stored.(*Bill), nil
}

// createRecurringSubscriptions crée les Subscription pour chaque groupe
// (peer × BillingStrategy) dont la stratégie est récurrente.
// Modifie les PeerItemOrder en place (SubscriptionID).
// Retourne les IDs de subscriptions créées.
func createRecurringSubscriptions(b *Bill, request *tools.APIRequest) ([]string, error) {
	subIDs := []string{}

	for peerID, po := range b.SubOrders {
		// Groupe les items récurrents par BillingStrategy
		byStrategy := map[pricing.BillingStrategy][]*PeerItemOrder{}
		for _, item := range po.Items {
			if item.BillingStrategy == pricing.BILL_ONCE {
				continue
			}
			byStrategy[item.BillingStrategy] = append(byStrategy[item.BillingStrategy], item)
		}

		for strategy, items := range byStrategy {
			subItems := make([]*subscription.SubscriptionItem, 0, len(items))
			totalAmount := 0.0
			for _, item := range items {
				subItems = append(subItems, &subscription.SubscriptionItem{
					ResourceType: item.ResourceType,
					Quantity:     item.Quantity,
					UnitPrice:    item.UnitPriceHT,
				})
				totalAmount += item.UnitPriceHT * float64(item.Quantity)
			}

			var sub *subscription.Subscription
			switch strategy {
			case pricing.BILL_PER_YEAR:
				sub = subscription.NewYearlySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
			case pricing.BILL_PER_WEEK:
				sub = subscription.NewWeeklySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
			default: // BILL_PER_MONTH et tout autre cas récurrent
				sub = subscription.NewMonthlySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
			}
			sub.IsDraft = true

			res, _, err := subscription.NewAccessor(request).StoreOne(sub)
			if err != nil {
				return subIDs, err
			}
			storedSub := res.(*subscription.Subscription)
			subIDs = append(subIDs, storedSub.GetID())

			// Lie le SubscriptionID à chaque ligne concernée
			for _, item := range items {
				item.SubscriptionID = storedSub.GetID()
			}
		}
	}
	return subIDs, nil
}

func (d *Bill) GetAccessor(request *tools.APIRequest) utils.Accessor {
	return NewAccessor(request)
}

func (r *Bill) StoreDraftDefault() {
	r.IsDraft = true
}

func (r *Bill) CanUpdate(set utils.DBObject) (bool, utils.DBObject) {
	if !r.IsDraft && r.Status != set.(*Bill).Status {
		return true, &Bill{Status: set.(*Bill).Status}
	}
	return r.IsDraft, set
}

func (r *Bill) CanDelete() bool {
	return r.IsDraft
}

func (d *Bill) SumUpBill(request *tools.APIRequest) (*Bill, error) {
	for _, b := range d.SubOrders {
		err := b.SumUpBill(request)
		if err != nil {
			return d, err
		}
		d.Total += b.Total
	}
	return d, nil
}

// ---------------------------------------------------------------------------
// PeerOrder
// ---------------------------------------------------------------------------

type PeerOrder struct {
	Error          string                `json:"error,omitempty" bson:"error,omitempty"`
	PeerID         string                `json:"peer_id,omitempty" bson:"peer_id,omitempty"`
	Status         enum.CompletionStatus `json:"status" bson:"status" default:"0"`
	BillingAddress string                `json:"billing_address,omitempty" bson:"billing_address,omitempty"`
	Items          []*PeerItemOrder      `json:"items,omitempty" bson:"items,omitempty"`
	Total          float64               `json:"total,omitempty" bson:"total,omitempty"`
}

// IsFullySettled retourne vrai si toutes les lignes de ce peer sont réglées.
func (po *PeerOrder) IsFullySettled() bool {
	for _, item := range po.Items {
		if !item.Settled {
			return false
		}
	}
	return true
}

func PricedByType(dt tools.DataType) pricing.PricedItemITF {
	switch dt {
	case tools.PROCESSING_RESOURCE:
		return &resources.PricedProcessingResource{}
	case tools.STORAGE_RESOURCE:
		return &resources.PricedStorageResource{}
	case tools.DATA_RESOURCE:
		return &resources.PricedDataResource{}
	case tools.COMPUTE_RESOURCE:
		return &resources.PricedComputeResource{}
	case tools.WORKFLOW_RESOURCE:
		return &resources.PricedResource[*pricing.ExploitPricingProfile[pricing.TimePricingStrategy]]{}
	}
	return nil
}

func (d *PeerOrder) Pay(request *tools.APIRequest, response chan *PeerOrder, wg *sync.WaitGroup) {
	d.Status = enum.PENDING
	go func() {
		// DO SOMETHING TO PAY ON BLOCKCHAIN OR WHATEVER — UPDATE STATUS ON RETURN
		d.Status = enum.PAID // TO REMOVE LATER IT'S A MOCK
		if d.Status == enum.PAID {
			now := time.Now().UTC()
			for _, b := range d.Items {
				priced := PricedByType(b.ResourceType)
				bb, _ := json.Marshal(b.Item)
				json.Unmarshal(bb, priced)
				if !priced.IsPurchasable() {
					continue
				}
				accessor := purchase_resource.NewAccessor(request)
				accessor.StoreOne(&purchase_resource.PurchaseResource{
					ResourceID:   priced.GetID(),
					ResourceType: priced.GetType(),
					EndDate:      priced.GetLocationEnd(),
				})
				// Marque la ligne comme réglée
				b.Settled = true
				b.SettledAt = &now
			}
		}
		if d.Status != enum.PENDING {
			response <- d
		}
		wg.Done()
	}()
}

func (d *PeerOrder) SumUpBill(request *tools.APIRequest) error {
	for _, b := range d.Items {
		tot, err := b.GetPriceHT(request)
		if err != nil {
			return err
		}
		d.Total += tot
	}
	return nil
}

// ---------------------------------------------------------------------------
// PeerItemOrder
// ---------------------------------------------------------------------------

// PeerItemOrder est une ligne de facture pour un peer donné.
type PeerItemOrder struct {
	// ItemID identifie de manière unique cette ligne pour le suivi de règlement.
	ItemID       string                              `json:"item_id,omitempty" bson:"item_id,omitempty"`
	ResourceType tools.DataType                      `json:"datatype,omitempty" bson:"datatype,omitempty"`
	Quantity     int                                 `json:"quantity,omitempty" bson:"quantity,omitempty"`
	Purchase     *purchase_resource.PurchaseResource `json:"purchase,omitempty" bson:"purchase,omitempty"`
	Item         map[string]interface{}              `json:"item,omitempty" bson:"item,omitempty"`

	BillingStrategy pricing.BillingStrategy `json:"billing_strategy" bson:"billing_strategy"`
	PaymentType     pricing.PaymentType     `json:"payment_type" bson:"payment_type"`

	// UnitPriceHT est le prix unitaire HT calculé par SumUpBill/GetPriceHT.
	// Utilisé pour la création des subscriptions sans recalcul.
	UnitPriceHT float64 `json:"unit_price_ht,omitempty" bson:"unit_price_ht,omitempty"`

	// SubscriptionID référence la Subscription créée pour les lignes récurrentes.
	// Vide pour les lignes BILL_ONCE.
	SubscriptionID string `json:"subscription_id,omitempty" bson:"subscription_id,omitempty"`

	// Settled indique si cette ligne a été réglée (paiement confirmé).
	Settled   bool       `json:"settled" bson:"settled"`
	SettledAt *time.Time `json:"settled_at,omitempty" bson:"settled_at,omitempty"`
}

func (d *PeerItemOrder) GetPriceHT(request *tools.APIRequest) (float64, error) {
	if d.Purchase == nil {
		return 0, nil
	}
	priced := PricedByType(d.ResourceType)
	b, _ := json.Marshal(d.Item)
	err := json.Unmarshal(b, priced)
	if err != nil {
		return 0, err
	}
	accessor := purchase_resource.NewAccessor(request)
	search, code, _ := accessor.Search(&dbs.Filters{
		And: map[string][]dbs.Filter{
			"resource_id": {{Operator: dbs.EQUAL.String(), Value: priced.GetID()}},
		},
	}, "", d.Purchase.IsDraft, 0, 10000)
	if code == 200 && len(search) > 0 {
		for _, s := range search {
			if s.(*purchase_resource.PurchaseResource).EndDate == nil ||
				time.Now().UTC().After(*s.(*purchase_resource.PurchaseResource).EndDate) {
				return 0, nil
			}
		}
	}
	unitPrice, err := priced.GetPriceHT()
	if err != nil {
		return 0, err
	}
	d.UnitPriceHT = unitPrice // cache pour createRecurringSubscriptions
	return unitPrice * float64(d.Quantity), nil
}