package logic

import (
	"context"
	"errors"
	"testing"

	"spark-server/internal/infrastructure/id"
	"spark-server/internal/module/conversation/entity"
	"spark-server/internal/module/conversation/model"
	"spark-server/internal/pkg/errs"
)

func TestEnsureP2PAndUpdateLastMsg(t *testing.T) {
	ids, err := id.New(1)
	if err != nil {
		t.Fatal(err)
	}
	repo := model.NewMemoryP2P()
	svc := NewP2PService(repo, ids)
	ctx := t.Context()
	if _, err := svc.EnsureP2P(ctx, 0, 1); !errors.Is(err, errs.ErrInvalidArgument) {
		t.Fatalf("invalid %v", err)
	}
	if _, err := svc.EnsureP2P(ctx, 1, 1); !errors.Is(err, errs.ErrInvalidArgument) {
		t.Fatalf("same user %v", err)
	}
	cid, err := svc.EnsureP2P(ctx, 1, 2)
	if err != nil || cid <= 0 {
		t.Fatalf("create %d %v", cid, err)
	}
	again, err := svc.EnsureP2P(ctx, 2, 1)
	if err != nil || again != cid {
		t.Fatalf("idempotent %d %v", again, err)
	}
	if err := svc.UpdateLastMsg(ctx, cid, 99, 1); err != nil {
		t.Fatal(err)
	}
	got, err := repo.Get(ctx, cid)
	if err != nil || got.LastMsgID != 99 {
		t.Fatalf("last %+v %v", got, err)
	}
	if err := (*P2PService)(nil).UpdateLastMsg(ctx, cid, 1, 1); !errors.Is(err, errs.ErrAvailable) {
		t.Fatalf("nil svc %v", err)
	}
}

type stubP2P struct {
	existing  *entity.Conversation
	getErr    error
	createErr error
}

func (s stubP2P) GetP2P(context.Context, int64, int64) (*entity.Conversation, error) {
	if s.getErr != nil {
		return nil, s.getErr
	}
	if s.existing != nil {
		return s.existing, nil
	}
	return nil, errs.ErrNotFound
}

func (s stubP2P) CreateP2P(context.Context, *entity.Conversation, *entity.P2P, []*entity.Member) error {
	return s.createErr
}

func (s stubP2P) UpdateLastMsg(context.Context, int64, int64, int64) error { return nil }

type dupP2P struct {
	gets int
	id   int64
}

func (d *dupP2P) GetP2P(context.Context, int64, int64) (*entity.Conversation, error) {
	d.gets++
	if d.gets == 1 {
		return nil, errs.ErrNotFound
	}
	return &entity.Conversation{ID: d.id}, nil
}

func (d *dupP2P) CreateP2P(context.Context, *entity.Conversation, *entity.P2P, []*entity.Member) error {
	return errs.ErrDuplicate
}

func (d *dupP2P) UpdateLastMsg(context.Context, int64, int64, int64) error { return nil }

func TestEnsureP2PDuplicateAndErrors(t *testing.T) {
	ids, err := id.New(1)
	if err != nil {
		t.Fatal(err)
	}
	ctx := t.Context()
	dup := NewP2PService(&dupP2P{id: 9}, ids)
	id9, err := dup.EnsureP2P(ctx, 1, 2)
	if err != nil || id9 != 9 {
		t.Fatalf("dup %d %v", id9, err)
	}
	if _, err := NewP2PService(stubP2P{getErr: errs.ErrAvailable}, ids).EnsureP2P(ctx, 1, 2); !errors.Is(err, errs.ErrAvailable) {
		t.Fatalf("get %v", err)
	}
	if _, err := NewP2PService(stubP2P{createErr: errs.ErrInner}, ids).EnsureP2P(ctx, 1, 2); !errors.Is(err, errs.ErrInner) {
		t.Fatalf("create %v", err)
	}
}