package client

import (
	"fmt"
	"io"
	"os"
	"time"

	"forge.redroom.link/yves/meowlib"
	"github.com/google/uuid"
	"google.golang.org/protobuf/proto"
)

type Peer struct {
	Name string `json:"name,omitempty"`
	//	Conversation        []InternalMessage `json:"conversation,omitempty"`
	// My own keys for that peer
	MyIdentity     meowlib.KeyPair  `json:"my_identity,omitempty"`
	MyEncryptionKp meowlib.KeyPair  `json:"my_encryption_kp,omitempty"`
	MyLookupKp     meowlib.KeyPair  `json:"my_lookup_kp,omitempty"`
	MyPullServers  []meowlib.Server `json:"my_pull_servers,omitempty"`
	// Peer keys and infos
	Contact      meowlib.ContactCard `json:"contact,omitempty"`
	InvitationId string              `json:"invitation_id,omitempty"`
	// Internal management attributes
	Visible             bool      `json:"visible,omitempty"`
	VisiblePassword     string    `json:"visible_password,omitempty"`
	PasswordType        string    `json:"password_type,omitempty"`
	Blocked             bool      `json:"blocked,omitempty"`
	MessageNotification string    `json:"message_notification,omitempty"`
	OnionMode           bool      `json:"onion_mode,omitempty"`
	LastMessage         time.Time `json:"last_message,omitempty"`
	DbIds               []string  `json:"db_ids,omitempty"`
	dbPassword          string
}

type PeerList []Peer

type Group struct {
	Name    string `json:"name,omitempty"`
	Members []Peer `json:"members,omitempty"`
}

func (pl *PeerList) GetFromPublicKey(publickey string) *Peer {
	for _, peer := range *pl {
		if peer.Contact.ContactPublicKey == publickey {
			return &peer
		}
	}
	return nil
}

func (pl *PeerList) GetFromMyLookupKey(publickey string) *Peer {
	for _, peer := range *pl {
		if peer.MyLookupKp.Public == publickey {
			return &peer
		}
	}
	return nil
}

func (pl *PeerList) GetFromName(name string) *Peer {
	for _, peer := range *pl {
		if peer.Contact.Name == name {
			return &peer
		}
	}
	return nil
}

func (pl *PeerList) GetConversationRequests() []*meowlib.ToServerMessage_ConversationRequest {
	var list []*meowlib.ToServerMessage_ConversationRequest
	for _, peer := range *pl {
		var cr meowlib.ToServerMessage_ConversationRequest
		cr.LookupKey = peer.MyLookupKp.Public
		// TODO Add key signature
		list = append(list, &cr)
	}
	return list
}

func (p *Peer) BuildSimpleUserMessage(message []byte) (*meowlib.UserMessage, error) {
	var msg meowlib.UserMessage
	msg.Destination = p.Contact.LookupPublicKey
	msg.From = p.MyIdentity.Public
	msg.Data = message
	msg.Type = "1"
	msg.Status = &meowlib.UserMessage_ConversationStatus{}
	msg.Status.LocalUuid = uuid.New().String()
	return &msg, nil
}

func (p *Peer) BuildSingleFileMessage(filename string, message []byte) ([]meowlib.UserMessage, error) {
	var msgs []meowlib.UserMessage
	fi, err := os.Stat(filename)
	if err != nil {
		return nil, err
	}

	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	// declare chunk size
	maxSz := GetConfig().Chunksize

	// create buffer
	b := make([]byte, maxSz)
	chunk := 0
	for {
		// read content to buffer
		readTotal, err := file.Read(b)
		if err != nil {
			if err != io.EOF {
				return nil, err
			}
			break
		}
		var msg meowlib.UserMessage
		var file meowlib.File
		msg.Destination = p.Contact.LookupPublicKey
		msg.From = p.MyIdentity.Public
		file.Filename = fi.Name()
		file.Chunk = uint32(chunk)
		file.Data = b[:readTotal]
		file.Size = uint64(fi.Size())
		msg.Files = append(msg.Files, &file)
		msg.Type = "2"
		if chunk == 0 {
			msg.Status = &meowlib.UserMessage_ConversationStatus{}
			msg.Status.LocalUuid = uuid.New().String()
		}
		msgs = append(msgs, msg)
		chunk++
	}
	return msgs, nil
}

func (p *Peer) SerializeUserMessage(msg *meowlib.UserMessage) ([]byte, error) {
	out, err := proto.Marshal(msg)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (p *Peer) DeserializeUserMessage(data []byte) (*meowlib.UserMessage, error) {
	var msg meowlib.UserMessage
	err := proto.Unmarshal(data, &msg)
	if err != nil {
		return nil, err
	}
	return &msg, nil
}

// AsymEncryptMessage prepares a message to send to a specific peer contact
func (p *Peer) AsymEncryptMessage(Message []byte) (*meowlib.EncryptedMessage, error) {
	var enc *meowlib.EncryptedMessage
	enc, err := meowlib.AsymEncryptAndSign(p.Contact.EncryptionPublicKey, p.MyIdentity.Private, Message)
	if err != nil {
		fmt.Println(err.Error())
		return enc, err
	}
	return enc, err
}

// AsymDecryptMessage reads a message from a specific peer contact
func (p *Peer) AsymDecryptMessage(Message []byte, Signature []byte) (DecryptedMessage []byte, err error) {
	DecryptedMessage, err = meowlib.AsymDecryptAndCheck(p.MyEncryptionKp.Private, p.Contact.ContactPublicKey, Message, Signature)
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	return DecryptedMessage, err
}

// PackUserMessage will package the previously encrypted message for sending it to the peer in protobuff format
func (p *Peer) PackUserMessage(message []byte, signature []byte) *meowlib.PackedUserMessage {
	var msg meowlib.PackedUserMessage
	msg.Destination = p.Contact.LookupPublicKey
	msg.Payload = message
	msg.Signature = signature
	return &msg
}

func (p *Peer) UnPackUserMessage(protoPackedMessage []byte) (payload []byte, signature []byte, err error) {
	msg := &meowlib.PackedServerMessage{}
	if err := proto.Unmarshal(protoPackedMessage, msg); err != nil {
		return nil, nil, err
	}
	return msg.Payload, msg.Signature, nil
}

func (p *Peer) GetConversationRequest() *meowlib.ToServerMessage_ConversationRequest {
	var cr meowlib.ToServerMessage_ConversationRequest
	return &cr
}

func (p *Peer) ProcessOutboundUserMessage(usermessage *meowlib.UserMessage) (*meowlib.PackedUserMessage, error) {
	serializedMessage, err := p.SerializeUserMessage(usermessage)
	if err != nil {
		return nil, err
	}
	// Encrypting it
	enc, err := p.AsymEncryptMessage(serializedMessage)
	if err != nil {
		return nil, err
	}
	// Packing it
	packedMsg := p.PackUserMessage(enc.Data, enc.Signature)

	return packedMsg, nil
}

func (p *Peer) ProcessInboundUserMessage(message []byte, signature []byte) (*meowlib.UserMessage, error) {
	dec, err := p.AsymDecryptMessage(message, signature)
	if err != nil {
		return nil, err
	}
	msg, err := p.DeserializeUserMessage(dec)
	if err != nil {
		return nil, err
	}
	return msg, nil
}

func (p *Peer) SetDbPassword(password string) {
	p.dbPassword = password
}

func (p *Peer) GetDbPassword() string {
	return p.dbPassword
}

func (p *Peer) StoreMessage(msg []byte) {

}

func (p *Peer) LoadMessage(uid string) {

}

func (p *Peer) LoadLastMessages(qty int) {

}

func (p *Peer) GetLastMessageUuid(msg []byte) {

}