package model

import (
	"log"
	"sync"
	"time"
)

type Timeline struct {
	Messages []Message
	lock     sync.Mutex
}

// Message is a local representation of a given message sent over a group chat channel.
type Message struct {
	Timestamp          time.Time
	PeerID             string
	Message            string
	Signature          []byte
	Verified           bool
	PreviousMessageSig []byte
}

func (m *Message) IsBefore(message *Message) bool {
	if m.Timestamp.Before(message.Timestamp) {
		return true
	}
	return false
}

func compareSignatures(a []byte, b []byte) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

func (t *Timeline) Insert(mi *Message) {
	t.lock.Lock()
	insert := false
	place := len(t.Messages)
	for i, m := range t.Messages {

		if compareSignatures(m.Signature, mi.PreviousMessageSig) {
			log.Printf("comp %d %v %v %x %x", place, mi.Message, m.Message, m.Signature[0:3], mi.PreviousMessageSig[0:3])
			insert = true
			place = i + 1
			break
		}

		if mi.IsBefore(&m) {
			place = i
			insert = true
			break
		}
	}

	if insert == false {
		t.Messages = append(t.Messages, *mi)
	} else {
		temp := make([]Message, len(t.Messages)+1)
		copy(temp[0:place], t.Messages[0:place])
		temp[place] = *mi
		copy(temp[place+1:], t.Messages[place:])
		t.Messages = temp
	}
	t.lock.Unlock()
}