package object

import (
	"bytes"
	"crypto/ecdsa"
	"crypto/sha256"

	"github.com/nspcc-dev/neofs-api-go/pkg/container"
	"github.com/nspcc-dev/neofs-api-go/pkg/owner"
	"github.com/nspcc-dev/neofs-api-go/util/signature"
	"github.com/nspcc-dev/neofs-api-go/v2/object"
	"github.com/nspcc-dev/neofs-api-go/v2/refs"
	signatureV2 "github.com/nspcc-dev/neofs-api-go/v2/signature"
	crypto "github.com/nspcc-dev/neofs-crypto"
	"github.com/pkg/errors"
)

// Object represents NeoFS object that provides
// a convenient interface for working in isolation
// from the internal structure of an object.
//
// Object allows to work with the object in read-only
// mode as a reflection of the immutability of objects
// in the system.
type Object struct {
	rwObject
}

type rwObject struct {
	fin bool

	id *ID

	key, sig []byte

	cid *container.ID

	ownerID *owner.ID

	payloadChecksum *refs.Checksum

	payload []byte

	// TODO: add other fields
}

// Verify checks if object structure is correct.
func (o *Object) Verify() error {
	if o == nil {
		return nil
	}

	hdr := o.v2Header()

	data, err := hdr.StableMarshal(nil)
	if err != nil {
		return errors.Wrap(err, "could not marshal header")
	}

	hdrChecksum := sha256.Sum256(data)

	if !bytes.Equal(hdrChecksum[:], o.id.val) {
		return errors.New("invalid object identifier")
	}

	if err := signature.VerifyDataWithSource(
		signatureV2.StableMarshalerWrapper{
			SM: o.id.ToV2(),
		},
		func() (key, sig []byte) {
			return o.key, o.sig
		},
	); err != nil {
		return errors.Wrap(err, "invalid object ID signature")
	}

	return nil
}

// Address returns address of the object.
func (o *Object) Address() *Address {
	if o != nil {
		return &Address{
			cid: o.cid,
			oid: o.id,
		}
	}

	return nil
}

// GetPayload returns object payload bytes.
func (o *Object) GetPayload() []byte {
	if o != nil {
		return o.payload
	}

	return nil
}

// CutPayload copies object fields w/o payload.
func (o *Object) CutPayload() *Object {
	if o != nil {
		return &Object{
			rwObject: rwObject{
				fin:             o.fin,
				id:              o.id,
				key:             o.key,
				sig:             o.sig,
				cid:             o.cid,
				ownerID:         o.ownerID,
				payloadChecksum: o.payloadChecksum,
			},
		}
	}

	return nil
}

// ToV2 converts object to v2 Object message.
func (o *Object) ToV2() *object.Object {
	obj, _ := o.rwObject.ToV2(nil)

	return obj
}

func (o *rwObject) v2Header() *object.Header {
	hV2 := new(object.Header)
	hV2.SetContainerID(o.cid.ToV2())
	hV2.SetOwnerID(o.ownerID.ToV2())
	hV2.SetPayloadHash(o.payloadChecksum)
	// TODO: set other fields

	return hV2
}

func (o *rwObject) complete(key *ecdsa.PrivateKey) (*object.Header, error) {
	hdr := o.v2Header()

	hdrData, err := hdr.StableMarshal(nil)
	if err != nil {
		return nil, errors.Wrap(err, "could not marshal header")
	}

	o.id = new(ID)
	o.id.SetSHA256(sha256.Sum256(hdrData))

	if err := signature.SignDataWithHandler(
		key,
		signatureV2.StableMarshalerWrapper{
			SM: o.id.ToV2(),
		},
		func(key []byte, sig []byte) {
			o.key, o.sig = key, sig
		},
	); err != nil {
		return nil, errors.Wrap(err, "could sign object identifier")
	}

	o.fin = true

	return hdr, nil
}

// ToV2 calculates object identifier, signs structure and converts
// it to v2 Object message.
func (o *rwObject) ToV2(key *ecdsa.PrivateKey) (*object.Object, error) {
	if o == nil {
		return nil, nil
	}

	var (
		hdr *object.Header
		err error
	)

	if !o.fin {
		if key == nil {
			return nil, errors.Wrap(crypto.ErrEmptyPrivateKey, "could complete the object")
		}

		if hdr, err = o.complete(key); err != nil {
			return nil, errors.Wrapf(err, "could not complete the object")
		}
	} else {
		hdr = o.v2Header()
	}

	obj := new(object.Object)
	obj.SetObjectID(o.id.ToV2())
	obj.SetHeader(hdr)
	obj.SetPayload(o.payload)

	sig := new(refs.Signature)
	sig.SetKey(o.key)
	sig.SetSign(o.sig)
	obj.SetSignature(sig)

	return obj, nil
}

// FromV2 converts v2 Object message to Object instance.
//
// Returns any error encountered which prevented the
// recovery of object data from the message.
func FromV2(oV2 *object.Object) (*Object, error) {
	if oV2 == nil {
		return nil, nil
	}

	id, err := IDFromV2(oV2.GetObjectID())
	if err != nil {
		return nil, errors.Wrap(err, "could not convert object ID")
	}

	hdr := oV2.GetHeader()

	ownerID, err := owner.IDFromV2(hdr.GetOwnerID())
	if err != nil {
		return nil, errors.Wrap(err, "could not convert owner ID")
	}

	cid, err := container.IDFromV2(hdr.GetContainerID())
	if err != nil {
		return nil, errors.Wrap(err, "could not convert container ID")
	}

	// TODO: convert other fields

	sig := oV2.GetSignature()

	return &Object{
		rwObject: rwObject{
			fin:             true,
			id:              id,
			key:             sig.GetKey(),
			sig:             sig.GetSign(),
			cid:             cid,
			ownerID:         ownerID,
			payloadChecksum: hdr.GetPayloadHash(),
			payload:         oV2.GetPayload(),
		},
	}, nil
}

// FromBytes restores Object from a binary representation.
func FromBytes(data []byte) (*Object, error) {
	oV2 := new(object.Object)
	if err := oV2.StableUnmarshal(data); err != nil {
		return nil, errors.Wrap(err, "could not unmarshal object")
	}

	return FromV2(oV2)
}