package notifier

import (
	"log"
	"reflect"
	"sort"
	"testing"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/icrowley/fake"
	"github.com/stretchr/testify/assert"

	"rocketgit.ru/rsmon/worker/app/models"
	"rocketgit.ru/rsmon/worker/config/database"
	"rocketgit.ru/rsmon/worker/spec/factories"
)

func init() {
	database.Init()
}

func TestCreatesMessages(t *testing.T) {
	log.Println("TestCreatesMessages")
	models.Drop()
	models.Migrate()
	user := factories.PersistedUser("test@test.ru", "123")
	account, err := models.CreateAccountForUser(fake.Company(), &user)
	contact := factories.PersistedContact(account, &user)
	group := factories.PersistedGroup(account)
	notification := factories.PersistedNotification(account, []int64{contact.ID}, []int64{group.ID}, 300, false)
	monitor := factories.PersistedMonitor(&group)

	event := factories.PersistedEvent(&monitor, "current", "test event 1")
	tn := time.Now()
	tStart := tn.Add(-30 * time.Minute)
	event.StartTime = &tStart
	err = models.DB().Save(&event).Error
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, event.GetDuration(tn), int64(30*60))

	log.Println("run first")
	Run()
	shoudHaveMessages("1a - contact should receive messages", t, "down", notification.ID, contact.ID, []int64{event.ID})

	// Run again
	log.Println("run again")
	Run()
	shoudHaveMessages("1b - contact should not receive more than one message", t, "down", notification.ID, contact.ID, []int64{event.ID})
}

func TestAggregatesMessages(t *testing.T) {
	log.Println("TestAggregatesMessages")
	models.Drop()
	models.Migrate()
	user := factories.PersistedUser("test@test.ru", "123")
	account, err := models.CreateAccountForUser(fake.Company(), &user)
	contact := factories.PersistedContact(account, &user)
	group := factories.PersistedGroup(account)
	notification := factories.PersistedNotification(account, []int64{contact.ID}, []int64{group.ID}, 300, false)

	monitor1 := factories.PersistedMonitor(&group)
	monitor2 := factories.PersistedMonitor(&group)

	event1 := factories.PersistedEvent(&monitor1, "current", "test event 2")
	tStart := time.Now().Add(-30 * time.Minute)
	event1.StartTime = &tStart
	err = models.DB().Save(&event1).Error
	if err != nil {
		t.Fatal(err)
	}

	event2 := factories.PersistedEvent(&monitor2, "current", "test event 3")
	tStart = time.Now().Add(-5 * time.Minute)
	event2.StartTime = &tStart
	err = models.DB().Save(&event2).Error
	if err != nil {
		t.Fatal(err)
	}

	Run()
	shoudHaveMessages("2 - messages for multiple events should be aggegated", t, "down", notification.ID, contact.ID, []int64{event1.ID, event2.ID})
}

func TestDoesNotCreateEnded(t *testing.T) {
	log.Println("TestDoesNotCreateEnded")
	models.Drop()
	models.Migrate()
	user := factories.PersistedUser("test@test.ru", "123")
	account, err := models.CreateAccountForUser(fake.Company(), &user)
	contact := factories.PersistedContact(account, &user)
	group := factories.PersistedGroup(account)
	notification := factories.PersistedNotification(account, []int64{contact.ID}, []int64{group.ID}, 300, false)
	monitor := factories.PersistedMonitor(&group)

	event := factories.PersistedEvent(&monitor, "ended", "test event 1")
	tStart := time.Now().Add(-90 * time.Minute)
	tEnd := time.Now().Add(-80 * time.Minute)
	event.StartTime = &tStart
	event.EndTime = &tEnd
	err = models.DB().Save(&event).Error
	if err != nil {
		t.Fatal(err)
	}

	Run()
	shoudHaveMessages("1 - contact should have no messages for ended notification", t, "down", notification.ID, contact.ID, []int64{})
}

func shoudHaveMessages(message string, t *testing.T, kind string, notificationID, contactID int64, wantIds []int64) {
	q := models.DB()
	if notificationID > 0 {
		q = q.Where("notification_id = ?", notificationID)
	}
	if contactID > 0 {
		q = q.Where("contact_id = ?", contactID)
	}

	messages := make([]models.Message, 0)
	err := models.MessageScope(q).Where("state IN ('queued')").Find(&messages).Error
	if err != nil {
		t.Fatal(err)
	}

	if len(messages) > 1 {
		spew.Dump(messages)
		t.Fatal("found more than one message")
	}

	haveIds := make([]int64, 0)
	for _, msg := range messages {
		assert.Equal(t, "queued", msg.State, "message should be in queued state")
		assert.Equal(t, kind, msg.Kind, "message should have kind = down")
		if len(msg.Events) > 0 {
			if kind != "down" && kind != "up" {
				t.Fatal(kind + " message should have no events")
			}
			for _, evt := range msg.Events {
				haveIds = append(haveIds, evt.ID)
			}
		} else if msg.CheckID != nil {
			if kind != "exp" {
				t.Fatal(kind + " message should have no check")
			}

			haveIds = append(haveIds, *msg.CheckID)
		}
	}

	if len(haveIds) != len(wantIds) {
		t.Fatal(message, notificationID, contactID, "bad count, have", len(haveIds), "want", len(wantIds))
	}

	sort.SliceStable(wantIds, func(i, j int) bool { return wantIds[i] < wantIds[j] })
	sort.SliceStable(haveIds, func(i, j int) bool { return haveIds[i] < haveIds[j] })

	if !reflect.DeepEqual(wantIds, haveIds) {
		t.Fatal(message, "bad want/have", wantIds, haveIds)
	}
}