package pub

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"

	"github.com/superseriousbusiness/activity/streams"
	"github.com/superseriousbusiness/activity/streams/vocab"
)

// baseActor must satisfy the Actor interface.
var _ Actor = &baseActor{}

// baseActor is an application-independent ActivityPub implementation. It does
// not implement the entire protocol, and relies on a delegate to do so. It
// only implements the part of the protocol that is side-effect-free, allowing
// an existing application to write a DelegateActor that glues their application
// into the ActivityPub world.
//
// It is preferred to use a DelegateActor provided by this library, so that the
// application does not need to worry about the ActivityPub implementation.
type baseActor struct {
	// delegate contains application-specific delegation logic.
	delegate DelegateActor
	// enableSocialProtocol enables or disables the Social API, the client to
	// server part of ActivityPub. Useful if permitting remote clients to
	// act on behalf of the users of the client application.
	enableSocialProtocol bool
	// enableFederatedProtocol enables or disables the Federated Protocol, or the
	// server to server part of ActivityPub. Useful to permit integrating
	// with the rest of the federative web.
	enableFederatedProtocol bool
	// clock simply tracks the current time.
	clock Clock
}

// baseActorFederating must satisfy the FederatingActor interface.
var _ FederatingActor = &baseActorFederating{}

// baseActorFederating is a baseActor that also satisfies the FederatingActor
// interface.
//
// The baseActor is preserved as an Actor which will not successfully cast to a
// FederatingActor.
type baseActorFederating struct {
	baseActor
}

// NewSocialActor builds a new Actor concept that handles only the Social
// Protocol part of ActivityPub.
//
// This Actor can be created once in an application and reused to handle
// multiple requests concurrently and for different endpoints.
//
// It leverages as much of go-fed as possible to ensure the implementation is
// compliant with the ActivityPub specification, while providing enough freedom
// to be productive without shooting one's self in the foot.
//
// Do not try to use NewSocialActor and NewFederatingActor together to cover
// both the Social and Federating parts of the protocol. Instead, use NewActor.
func NewSocialActor(c CommonBehavior,
	c2s SocialProtocol,
	db Database,
	clock Clock) Actor {
	return &baseActor{
		// Use SideEffectActor without s2s.
		delegate:             NewSideEffectActor(c, nil, c2s, db, clock),
		enableSocialProtocol: true,
		clock:                clock,
	}
}

// NewFederatingActor builds a new Actor concept that handles only the Federating
// Protocol part of ActivityPub.
//
// This Actor can be created once in an application and reused to handle
// multiple requests concurrently and for different endpoints.
//
// It leverages as much of go-fed as possible to ensure the implementation is
// compliant with the ActivityPub specification, while providing enough freedom
// to be productive without shooting one's self in the foot.
//
// Do not try to use NewSocialActor and NewFederatingActor together to cover
// both the Social and Federating parts of the protocol. Instead, use NewActor.
func NewFederatingActor(c CommonBehavior,
	s2s FederatingProtocol,
	db Database,
	clock Clock) FederatingActor {
	return &baseActorFederating{
		baseActor{
			// Use SideEffectActor without c2s.
			delegate:                NewSideEffectActor(c, s2s, nil, db, clock),
			enableFederatedProtocol: true,
			clock:                   clock,
		},
	}
}

// NewActor builds a new Actor concept that handles both the Social and
// Federating Protocol parts of ActivityPub.
//
// This Actor can be created once in an application and reused to handle
// multiple requests concurrently and for different endpoints.
//
// It leverages as much of go-fed as possible to ensure the implementation is
// compliant with the ActivityPub specification, while providing enough freedom
// to be productive without shooting one's self in the foot.
func NewActor(c CommonBehavior,
	c2s SocialProtocol,
	s2s FederatingProtocol,
	db Database,
	clock Clock) FederatingActor {
	return &baseActorFederating{
		baseActor{
			delegate:                NewSideEffectActor(c, s2s, c2s, db, clock),
			enableSocialProtocol:    true,
			enableFederatedProtocol: true,
			clock:                   clock,
		},
	}
}

// NewCustomActor allows clients to create a custom ActivityPub implementation
// for the Social Protocol, Federating Protocol, or both.
//
// It still uses the library as a high-level scaffold, which has the benefit of
// allowing applications to grow into a custom ActivityPub solution without
// having to refactor the code that passes HTTP requests into the Actor.
//
// It is possible to create a DelegateActor that is not ActivityPub compliant.
// Use with due care.
//
// If you find yourself passing a SideEffectActor in as the DelegateActor,
// consider using NewActor, NewFederatingActor, or NewSocialActor instead.
func NewCustomActor(delegate DelegateActor,
	enableSocialProtocol, enableFederatedProtocol bool,
	clock Clock) FederatingActor {
	return &baseActorFederating{
		baseActor{
			delegate:                delegate,
			enableSocialProtocol:    enableSocialProtocol,
			enableFederatedProtocol: enableFederatedProtocol,
			clock:                   clock,
		},
	}
}

// PostInbox implements the generic algorithm for handling a POST request to an
// actor's inbox independent on an application. It relies on a delegate to
// implement application specific functionality.
//
// Only supports serving data with identifiers having the HTTPS scheme.
func (b *baseActor) PostInbox(c context.Context, w http.ResponseWriter, r *http.Request) (bool, error) {
	return b.PostInboxScheme(c, w, r, "https")
}

// PostInbox implements the generic algorithm for handling a POST request to an
// actor's inbox independent on an application. It relies on a delegate to
// implement application specific functionality.
//
// Specifying the "scheme" allows for retrieving ActivityStreams content with
// identifiers such as HTTP, HTTPS, or other protocol schemes.
func (b *baseActor) PostInboxScheme(c context.Context, w http.ResponseWriter, r *http.Request, scheme string) (bool, error) {
	// Do nothing if it is not an ActivityPub POST request.
	if !isActivityPubPost(r) {
		return false, nil
	}
	// If the Federated Protocol is not enabled, then this endpoint is not
	// enabled.
	if !b.enableFederatedProtocol {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return true, nil
	}
	// Check the peer request is authentic.
	c, authenticated, err := b.delegate.AuthenticatePostInbox(c, w, r)
	if err != nil {
		return true, err
	} else if !authenticated {
		return true, nil
	}
	// Begin processing the request, but have not yet applied
	// authorization (ex: blocks). Obtain the activity reject unknown
	// activities.
	m, err := readActivityPubReq(r)
	if err != nil {
		return true, err
	}
	asValue, err := streams.ToType(c, m)
	if err != nil && !streams.IsUnmatchedErr(err) {
		return true, err
	} else if streams.IsUnmatchedErr(err) {
		// Respond with bad request -- we do not understand the type.
		w.WriteHeader(http.StatusBadRequest)
		return true, nil
	}
	activity, ok := asValue.(Activity)
	if !ok {
		return true, fmt.Errorf("activity streams value is not an Activity: %T", asValue)
	}
	if activity.GetJSONLDId() == nil {
		w.WriteHeader(http.StatusBadRequest)
		return true, nil
	}
	// Allow server implementations to set context data with a hook.
	c, err = b.delegate.PostInboxRequestBodyHook(c, r, activity)
	if err != nil {
		return true, err
	}
	// Check authorization of the activity.
	authorized, err := b.delegate.AuthorizePostInbox(c, w, activity)
	if err != nil {
		return true, err
	} else if !authorized {
		return true, nil
	}
	// Post the activity to the actor's inbox and trigger side effects for
	// that particular Activity type. It is up to the delegate to resolve
	// the given map.
	inboxId := requestId(r, scheme)
	err = b.delegate.PostInbox(c, inboxId, activity)
	if err != nil {
		// Special case: We know it is a bad request if the object or
		// target properties needed to be populated, but weren't.
		//
		// Send the rejection to the peer.
		if err == ErrObjectRequired || err == ErrTargetRequired {
			w.WriteHeader(http.StatusBadRequest)
			return true, nil
		}
		return true, err
	}
	// Our side effects are complete, now delegate determining whether to
	// do inbox forwarding, as well as the action to do it.
	if err := b.delegate.InboxForwarding(c, inboxId, activity); err != nil {
		return true, err
	}
	// Request has been processed. Begin responding to the request.
	//
	// Simply respond with an OK status to the peer.
	w.WriteHeader(http.StatusOK)
	return true, nil
}

// GetInbox implements the generic algorithm for handling a GET request to an
// actor's inbox independent on an application. It relies on a delegate to
// implement application specific functionality.
func (b *baseActor) GetInbox(c context.Context, w http.ResponseWriter, r *http.Request) (bool, error) {
	// Do nothing if it is not an ActivityPub GET request.
	if !isActivityPubGet(r) {
		return false, nil
	}
	// Delegate authenticating and authorizing the request.
	c, authenticated, err := b.delegate.AuthenticateGetInbox(c, w, r)
	if err != nil {
		return true, err
	} else if !authenticated {
		return true, nil
	}
	// Everything is good to begin processing the request.
	oc, err := b.delegate.GetInbox(c, r)
	if err != nil {
		return true, err
	}
	// Deduplicate the 'orderedItems' property by ID.
	err = dedupeOrderedItems(oc)
	if err != nil {
		return true, err
	}
	// Request has been processed. Begin responding to the request.
	//
	// Serialize the OrderedCollection.
	m, err := streams.Serialize(oc)
	if err != nil {
		return true, err
	}
	raw, err := json.Marshal(m)
	if err != nil {
		return true, err
	}
	// Write the response.
	addResponseHeaders(w.Header(), b.clock, raw)
	w.WriteHeader(http.StatusOK)
	n, err := w.Write(raw)
	if err != nil {
		return true, err
	} else if n != len(raw) {
		return true, fmt.Errorf("ResponseWriter.Write wrote %d of %d bytes", n, len(raw))
	}
	return true, nil
}

// PostOutbox implements the generic algorithm for handling a POST request to an
// actor's outbox independent on an application. It relies on a delegate to
// implement application specific functionality.
//
// Only supports serving data with identifiers having the HTTPS scheme.
func (b *baseActor) PostOutbox(c context.Context, w http.ResponseWriter, r *http.Request) (bool, error) {
	return b.PostOutboxScheme(c, w, r, "https")
}

// PostOutbox implements the generic algorithm for handling a POST request to an
// actor's outbox independent on an application. It relies on a delegate to
// implement application specific functionality.
//
// Specifying the "scheme" allows for retrieving ActivityStreams content with
// identifiers such as HTTP, HTTPS, or other protocol schemes.
func (b *baseActor) PostOutboxScheme(c context.Context, w http.ResponseWriter, r *http.Request, scheme string) (bool, error) {
	// Do nothing if it is not an ActivityPub POST request.
	if !isActivityPubPost(r) {
		return false, nil
	}
	// If the Social API is not enabled, then this endpoint is not enabled.
	if !b.enableSocialProtocol {
		w.WriteHeader(http.StatusMethodNotAllowed)
		return true, nil
	}
	// Delegate authenticating and authorizing the request.
	c, authenticated, err := b.delegate.AuthenticatePostOutbox(c, w, r)
	if err != nil {
		return true, err
	} else if !authenticated {
		return true, nil
	}
	// Everything is good to begin processing the request.
	m, err := readActivityPubReq(r)
	if err != nil {
		return true, err
	}
	// Note that converting to a Type will NOT successfully convert types
	// not known to go-fed. This prevents accidentally wrapping an Activity
	// type unknown to go-fed in a Create below. Instead,
	// streams.ErrUnhandledType will be returned here.
	asValue, err := streams.ToType(c, m)
	if err != nil && !streams.IsUnmatchedErr(err) {
		return true, err
	} else if streams.IsUnmatchedErr(err) {
		// Respond with bad request -- we do not understand the type.
		w.WriteHeader(http.StatusBadRequest)
		return true, nil
	}
	// Allow server implementations to set context data with a hook.
	c, err = b.delegate.PostOutboxRequestBodyHook(c, r, asValue)
	if err != nil {
		return true, err
	}
	// The HTTP request steps are complete, complete the rest of the outbox
	// and delivery process.
	outboxId := requestId(r, scheme)
	activity, err := b.deliver(c, outboxId, asValue, m)
	// Special case: We know it is a bad request if the object or
	// target properties needed to be populated, but weren't.
	//
	// Send the rejection to the client.
	if err == ErrObjectRequired || err == ErrTargetRequired {
		w.WriteHeader(http.StatusBadRequest)
		return true, nil
	} else if err != nil {
		return true, err
	}
	// Respond to the request with the new Activity's IRI location.
	w.Header().Set(locationHeader, activity.GetJSONLDId().Get().String())
	w.WriteHeader(http.StatusCreated)
	return true, nil
}

// GetOutbox implements the generic algorithm for handling a Get request to an
// actor's outbox independent on an application. It relies on a delegate to
// implement application specific functionality.
func (b *baseActor) GetOutbox(c context.Context, w http.ResponseWriter, r *http.Request) (bool, error) {
	// Do nothing if it is not an ActivityPub GET request.
	if !isActivityPubGet(r) {
		return false, nil
	}
	// Delegate authenticating and authorizing the request.
	c, authenticated, err := b.delegate.AuthenticateGetOutbox(c, w, r)
	if err != nil {
		return true, err
	} else if !authenticated {
		return true, nil
	}
	// Everything is good to begin processing the request.
	oc, err := b.delegate.GetOutbox(c, r)
	if err != nil {
		return true, err
	}
	// Request has been processed. Begin responding to the request.
	//
	// Serialize the OrderedCollection.
	m, err := streams.Serialize(oc)
	if err != nil {
		return true, err
	}
	raw, err := json.Marshal(m)
	if err != nil {
		return true, err
	}
	// Write the response.
	addResponseHeaders(w.Header(), b.clock, raw)
	w.WriteHeader(http.StatusOK)
	n, err := w.Write(raw)
	if err != nil {
		return true, err
	} else if n != len(raw) {
		return true, fmt.Errorf("ResponseWriter.Write wrote %d of %d bytes", n, len(raw))
	}
	return true, nil
}

// deliver delegates all outbox handling steps and optionally will federate the
// activity if the federated protocol is enabled.
//
// This function is not exported so an Actor that only supports C2S cannot be
// type casted to a FederatingActor. It doesn't exactly fit the Send method
// signature anyways.
//
// Note: 'm' is nilable.
func (b *baseActor) deliver(c context.Context, outbox *url.URL, asValue vocab.Type, m map[string]interface{}) (activity Activity, err error) {
	// If the value is not an Activity or type extending from Activity, then
	// we need to wrap it in a Create Activity.
	if !streams.IsOrExtendsActivityStreamsActivity(asValue) {
		asValue, err = b.delegate.WrapInCreate(c, asValue, outbox)
		if err != nil {
			return
		}
	}
	// At this point, this should be a safe conversion. If this error is
	// triggered, then there is either a bug in the delegation of
	// WrapInCreate, behavior is not lining up in the generated ExtendedBy
	// code, or something else is incorrect with the type system.
	var ok bool
	activity, ok = asValue.(Activity)
	if !ok {
		err = fmt.Errorf("activity streams value is not an Activity: %T", asValue)
		return
	}
	// Delegate generating new IDs for the activity and all new objects.
	if err = b.delegate.AddNewIDs(c, activity); err != nil {
		return
	}
	// Post the activity to the actor's outbox and trigger side effects for
	// that particular Activity type.
	//
	// Since 'm' is nil-able and side effects may need access to literal nil
	// values, such as for Update activities, ensure 'm' is non-nil.
	if m == nil {
		m, err = asValue.Serialize()
		if err != nil {
			return
		}
	}
	deliverable, err := b.delegate.PostOutbox(c, activity, outbox, m)
	if err != nil {
		return
	}
	// Request has been processed and all side effects internal to this
	// application server have finished. Begin side effects affecting other
	// servers and/or the client who sent this request.
	//
	// If we are federating and the type is a deliverable one, then deliver
	// the activity to federating peers.
	if b.enableFederatedProtocol && deliverable {
		if err = b.delegate.Deliver(c, outbox, activity); err != nil {
			return
		}
	}
	return
}

// Send is programmatically accessible if the federated protocol is enabled.
func (b *baseActorFederating) Send(c context.Context, outbox *url.URL, t vocab.Type) (Activity, error) {
	return b.deliver(c, outbox, t, nil)
}