package registry

import (
	"context"
	"encoding/json"
)

type remoteRequest struct {
	Method         string
	Deadline       int64
	CallbackError  string
	CallbackFailed bool
	Host           string
	Owner          ClaimOwnership
	Expected       string
	Next           string
	Observed       Route
	Journal        string
	Targets        []ClaimRow
	ObservedValue  Timer
	T              Timer
	Name           string
	Registration   string
	Status         string
	Now            int64
	Id             string
	Retirement     string
	Old            ColdRows
	NextValue      ColdRows
	F              Fleet
	B              FleetBox
	Fleet          string
	Label          string
	TokenHash      string
	Tags           string
	IdValue        int64
	Sqid           string
	TValue         Route
	Op             string
	ExpectOp       string
	ToOp           string
	FromOp         string
	Account        string
	Channel        string
	From           string
	To             string
	FromDB         string
	FromSock       string
	ToDB           string
	ToSock         string
	Backing        string
	Unit           string
	Class          string
	Addr           string
	Addrs          string
	Health         string
	Steering       string
	UpdateSettings string
	BuildState     string
	Replicas       string
	Replica        bool
	Hash           string
	Hosts          []string
	Env            string
	Tunnel         string
	Target         string
	CheckedAt      int64
	At             int64
	Ver            string
	Prev           string
	On             bool
	Due            int64
	Seed           string
	Args           string
	Idle           int
	MaxRun         int
	A              RouteAlias
	Alias          string
	W              WildcardDomain
	P              RoutePath
	Prefix         string
	Path           string
	Rows           []Timer
	Limit          int
	ExcludeHosts   []string
	Ms             int64
	Attempts       int
	NextAt         int64
	Kind           string
	Alive          map[string]bool
	DoneBefore     int64
	Keep           map[string]bool
	ExpectGood     GoodBuild
	NextGood       GoodBuild
}

type remoteResponse struct {
	Failed     bool
	Error      string
	ErrorKind  int
	Callback   string
	Held       []Route
	Archives   []ClaimRowArchive
	Timer      *Timer
	Changed    bool
	Fleet      *Fleet
	Fleets     []Fleet
	FleetBoxes []FleetBox
	StringMap  map[string]string
	Number64   int64
	Text       string
	Accounts   []Account
	Routes     []Route
	Route      *Route
	Aliases    []RouteAlias
	Wildcards  []WildcardDomain
	Paths      []RoutePath
	Timers     []Timer
	Number     int
	Times      map[string]int64
	Hosts      []string
}

func (r *Registry) dispatchRemote(ctx context.Context, q remoteRequest, callback func(remoteResponse) error) (out remoteResponse, err error) {
	switch q.Method {
	case "ArtifactHosts":
		out.Hosts, err = r.ArtifactHosts()
	case "SetClaimHold":
		err = r.SetClaimHold(ctx, q.Host, q.Owner, q.Expected, q.Next)
	case "AdoptClaimRoute":
		err = r.AdoptClaimRoute(ctx, q.Observed, q.Owner)
	case "RetireClaimRows":
		err = r.RetireClaimRows(ctx, q.Journal, q.Targets, func(archives []ClaimRowArchive) error {
			return callback(remoteResponse{Callback: "archives", Archives: archives})
		})
	case "AdoptClaimTimer":
		err = r.AdoptClaimTimer(ctx, q.ObservedValue, q.Owner)
	case "MaterializeTimerRegistration":
		out.Timer, err = r.MaterializeTimerRegistration(q.T, q.Expected)
	case "DeleteTimerOwnedRegistration":
		err = r.DeleteTimerOwnedRegistration(q.T)
	case "UpsertTimerRegistration":
		out.Timer, err = r.UpsertTimerRegistration(q.T, q.Expected)
	case "SetTimerStatusRegistration":
		err = r.SetTimerStatusRegistration(q.Host, q.Name, q.Registration, q.Status)
	case "FireTimerNowRegistration":
		err = r.FireTimerNowRegistration(q.Host, q.Name, q.Registration, q.Now)
	case "ReviseRecoveryHandover":
		err = r.ReviseRecoveryHandover(ctx, q.Id, q.Expected, q.Journal)
	case "PendingRecoveryHandovers":
		var bodies map[string]string
		bodies, err = r.PendingRecoveryHandovers(ctx)
		if err == nil {
			var raw []byte
			raw, err = json.Marshal(bodies)
			out.Text = string(raw)
		}
	case "BeginRecoveryHandover":
		err = r.BeginRecoveryHandover(ctx, q.Id, q.Journal)
	case "PendingRecoveryHandover":
		out.Text, err = r.PendingRecoveryHandover(ctx, q.Id)
	case "CompleteRecoveryHandover":
		err = r.CompleteRecoveryHandover(ctx, q.Id, q.Journal)
	case "RebindClaimRows":
		err = r.RebindClaimRows(ctx, q.Old, q.NextValue)
	case "RestoreClaimRows":
		err = r.RestoreClaimRows(ctx, q.Id, q.Retirement, q.Old, q.NextValue)
	case "UpsertFleet":
		err = r.UpsertFleet(q.F)
	case "CreateFleet":
		out.Changed, err = r.CreateFleet(q.F)
	case "GetFleet":
		out.Fleet, err = r.GetFleet(q.Name)
	case "ListFleets":
		out.Fleets, err = r.ListFleets()
	case "AddFleetBox":
		err = r.AddFleetBox(q.B)
	case "SetFleetBoxToken":
		err = r.SetFleetBoxToken(q.Fleet, q.Label, q.TokenHash)
	case "SetFleetBoxTags":
		err = r.SetFleetBoxTags(q.Fleet, q.Label, q.Tags)
	case "SetFleetBoxStatus":
		err = r.SetFleetBoxStatus(q.Fleet, q.Label, q.Status)
	case "ListFleetBoxes":
		out.FleetBoxes, err = r.ListFleetBoxes(q.Fleet)
	case "FleetChannelAuth":
		out.StringMap, err = r.FleetChannelAuth()
	case "PutAccount":
		err = r.PutAccount(q.IdValue, q.Sqid, q.Name)
	case "DeleteAccount":
		err = r.DeleteAccount(q.Sqid)
	case "AccountBySqid":
		out.Number64, out.Text, err = r.AccountBySqid(q.Sqid)
	case "Accounts":
		out.Accounts, err = r.Accounts()
	case "ImportJournalHosts":
		out.Hosts, err = r.ImportJournalHosts()
	case "List":
		out.Routes, err = r.List()
	case "Get":
		out.Route, err = r.Get(q.Host)
	case "Delete":
		err = r.Delete(q.Host)
	case "Upsert":
		err = r.Upsert(q.TValue)
	case "SetHold":
		err = r.SetHold(q.Host, q.Status, q.Op)
	case "SetHoldIf":
		out.Changed, err = r.SetHoldIf(q.Host, q.Status, q.Op, q.ExpectOp)
	case "HandHold":
		out.Changed, err = r.HandHold(q.Host, q.Status, q.ToOp, q.FromOp)
	case "ReleaseHold":
		out.Changed, err = r.ReleaseHold(q.Host, q.Op)
	case "DeleteIfHold":
		out.Changed, err = r.DeleteIfHold(q.Host, q.Op)
	case "DeleteIfHoldWithTimers":
		out.Changed, err = r.DeleteIfHoldWithTimers(q.Host, q.Op)
	case "HoldRows":
		out.Routes, err = r.HoldRows()
	case "WithHoldsFrozen":
		err = r.WithHoldsFrozen(func(held []Route) error { return callback(remoteResponse{Callback: "holds", Held: held}) })
	case "SetAccount":
		err = r.SetAccount(q.Host, q.Account)
	case "SetChannel":
		err = r.SetChannel(q.Host, q.Channel)
	case "SetStatus":
		err = r.SetStatus(q.Host, q.Status)
	case "SetCaps":
		err = r.SetCaps(q.Host, q.From, q.To)
	case "SetDBPath":
		err = r.SetDBPath(q.Host, q.From, q.To)
	case "SetInstancePaths":
		err = r.SetInstancePaths(q.Host, q.FromDB, q.FromSock, q.ToDB, q.ToSock)
	case "SetBacking":
		err = r.SetBacking(q.Host, q.Backing)
	case "SetUnit":
		err = r.SetUnit(q.Host, q.Unit)
	case "SetReplication":
		err = r.SetReplication(q.Host, q.Class)
	case "SetUpstreams":
		err = r.SetUpstreams(q.Host, q.Addr, q.Addrs, q.Health)
	case "SetSteering":
		err = r.SetSteering(q.Host, q.Steering)
	case "SetUpdateSettings":
		err = r.SetUpdateSettings(q.Host, q.UpdateSettings)
	case "SetBuildState":
		err = r.SetBuildState(q.Host, q.BuildState)
	case "SetReplicas":
		err = r.SetReplicas(q.Host, q.Replicas)
	case "SetReplica":
		err = r.SetReplica(q.Host, q.Replica)
	case "SetGate":
		err = r.SetGate(q.Host, q.Hash)
	case "SetChannels":
		err = r.SetChannels(q.Hosts, q.Channel)
	case "SetEnvironment":
		err = r.SetEnvironment(q.Host, q.Env)
	case "SetTunnel":
		err = r.SetTunnel(q.Host, q.Tunnel)
	case "SetFleetBox":
		err = r.SetFleetBox(q.Host, q.Label)
	case "SetPlacement":
		err = r.SetPlacement(q.Host, q.Target)
	case "SetEnvironments":
		err = r.SetEnvironments(q.Hosts, q.Env)
	case "SetChannelsAndEnvironments":
		err = r.SetChannelsAndEnvironments(q.Hosts, q.Channel, q.Env)
	case "SetDNSStatus":
		err = r.SetDNSStatus(q.Host, q.Status, q.CheckedAt)
	case "SetCertExpiresAt":
		err = r.SetCertExpiresAt(q.Host, q.At)
	case "SetVersions":
		err = r.SetVersions(q.Host, q.Ver, q.Prev)
	case "SetGoodBuild":
		err = r.SetGoodBuild(q.Host, q.ExpectGood, q.NextGood)
	case "SetServingVersion":
		err = r.SetServingVersion(q.Host, q.Ver)
	case "SetHibernate":
		err = r.SetHibernate(q.Host, q.On)
	case "SetNextDue":
		err = r.SetNextDue(q.Host, q.Due)
	case "ClearNextDueIf":
		err = r.ClearNextDueIf(q.Host, q.Due)
	case "AlwaysOnWorkers":
		out.Routes, err = r.AlwaysOnWorkers()
	case "SetSeed":
		err = r.SetSeed(q.Host, q.Seed)
	case "SetArgs":
		err = r.SetArgs(q.Host, q.Args)
	case "SetWorkerLimits":
		err = r.SetWorkerLimits(q.Host, q.Idle, q.MaxRun)
	case "SetProvisioned":
		err = r.SetProvisioned(q.Host, q.On)
	case "SetStatusNamed":
		err = r.SetStatusNamed(q.Host, q.On)
	case "DueInstances":
		out.Routes, err = r.DueInstances(q.Now)
	case "ListAliases":
		out.Aliases, err = r.ListAliases()
	case "UpsertAlias":
		err = r.UpsertAlias(q.A)
	case "DeleteAlias":
		err = r.DeleteAlias(q.Alias)
	case "SetAliasDNSStatus":
		err = r.SetAliasDNSStatus(q.Alias, q.Status, q.At)
	case "SetAliasCertExpiresAt":
		err = r.SetAliasCertExpiresAt(q.Alias, q.At)
	case "ListWildcardDomains":
		out.Wildcards, err = r.ListWildcardDomains()
	case "UpsertWildcardDomain":
		err = r.UpsertWildcardDomain(q.W)
	case "DeleteWildcardDomain":
		err = r.DeleteWildcardDomain(q.Host)
	case "ListPaths":
		out.Paths, err = r.ListPaths()
	case "UpsertPath":
		err = r.UpsertPath(q.P)
	case "DeletePath":
		err = r.DeletePath(q.Host, q.Prefix)
	case "Fingerprint":
		out.Text, err = r.Fingerprint()
	case "SnapshotFingerprint":
		out.Text, err = r.SnapshotFingerprint()
	case "SnapshotTo":
		err = r.SnapshotTo(q.Path)
	case "UpsertTimer":
		err = r.UpsertTimer(q.T)
	case "ReplaceTimers":
		err = r.ReplaceTimers(q.Host, q.Rows)
	case "GetTimer":
		out.Timer, err = r.GetTimer(q.Host, q.Name)
	case "DeleteTimer":
		err = r.DeleteTimer(q.Host, q.Name)
	case "DeleteTimerRegistration":
		err = r.DeleteTimerRegistration(q.Host, q.Name, q.Registration)
	case "TimersFor":
		out.Timers, err = r.TimersFor(q.Host)
	case "DueTimers":
		out.Timers, err = r.DueTimers(q.Now, q.Limit, q.ExcludeHosts)
	case "DueUnheldTimers":
		out.Timers, err = r.DueUnheldTimers(q.Now, q.Limit, q.ExcludeHosts)
	case "FireTimerNow":
		err = r.FireTimerNow(q.Host, q.Name, q.Now)
	case "MarkTimerFired":
		out.Changed, err = r.MarkTimerFired(q.Host, q.Name, q.Registration, q.At, q.Status, q.Ms, q.Attempts, q.NextAt, q.Due)
	case "SetTimerStatus":
		err = r.SetTimerStatus(q.Host, q.Name, q.Status)
	case "CountTimers":
		out.Number, err = r.CountTimers(q.Host, q.Kind)
	case "PruneTimers":
		out.Number, err = r.PruneTimers(q.Alive, q.DoneBefore)
	case "DeleteTimersExcept":
		out.Number, err = r.DeleteTimersExcept(q.Host, q.Kind, q.Keep)
	case "EarliestTimers":
		out.Times, err = r.EarliestTimers()
	default:
		err = errRemoteMethod
	}
	return
}