package swarm // import "github.com/docker/docker/api/server/router/swarm"

import (
	"context"
	"fmt"
	"net/http"

	"github.com/docker/docker/api/server/httputils"
	basictypes "github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/backend"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/api/types/swarm"
	"github.com/docker/docker/api/types/versions"
)

// swarmLogs takes an http response, request, and selector, and writes the logs
// specified by the selector to the response
func (sr *swarmRouter) swarmLogs(ctx context.Context, w http.ResponseWriter, r *http.Request, selector *backend.LogSelector) error {
	// Args are validated before the stream starts because when it starts we're
	// sending HTTP 200 by writing an empty chunk of data to tell the client that
	// daemon is going to stream. By sending this initial HTTP 200 we can't report
	// any error after the stream starts (i.e. container not found, wrong parameters)
	// with the appropriate status code.
	stdout, stderr := httputils.BoolValue(r, "stdout"), httputils.BoolValue(r, "stderr")
	if !(stdout || stderr) {
		return fmt.Errorf("Bad parameters: you must choose at least one stream")
	}

	// there is probably a neater way to manufacture the LogsOptions
	// struct, probably in the caller, to eliminate the dependency on net/http
	logsConfig := &container.LogsOptions{
		Follow:     httputils.BoolValue(r, "follow"),
		Timestamps: httputils.BoolValue(r, "timestamps"),
		Since:      r.Form.Get("since"),
		Tail:       r.Form.Get("tail"),
		ShowStdout: stdout,
		ShowStderr: stderr,
		Details:    httputils.BoolValue(r, "details"),
	}

	tty := false
	// checking for whether logs are TTY involves iterating over every service
	// and task. idk if there is a better way
	for _, service := range selector.Services {
		s, err := sr.backend.GetService(service, false)
		if err != nil {
			// maybe should return some context with this error?
			return err
		}
		tty = (s.Spec.TaskTemplate.ContainerSpec != nil && s.Spec.TaskTemplate.ContainerSpec.TTY) || tty
	}
	for _, task := range selector.Tasks {
		t, err := sr.backend.GetTask(task)
		if err != nil {
			// as above
			return err
		}
		tty = t.Spec.ContainerSpec.TTY || tty
	}

	msgs, err := sr.backend.ServiceLogs(ctx, selector, logsConfig)
	if err != nil {
		return err
	}

	contentType := basictypes.MediaTypeRawStream
	if !tty && versions.GreaterThanOrEqualTo(httputils.VersionFromContext(ctx), "1.42") {
		contentType = basictypes.MediaTypeMultiplexedStream
	}
	w.Header().Set("Content-Type", contentType)
	httputils.WriteLogStream(ctx, w, msgs, logsConfig, !tty)
	return nil
}

// adjustForAPIVersion takes a version and service spec and removes fields to
// make the spec compatible with the specified version.
func adjustForAPIVersion(cliVersion string, service *swarm.ServiceSpec) {
	if cliVersion == "" {
		return
	}
	if versions.LessThan(cliVersion, "1.46") {
		if service.TaskTemplate.ContainerSpec != nil {
			for i, mount := range service.TaskTemplate.ContainerSpec.Mounts {
				if mount.TmpfsOptions != nil {
					mount.TmpfsOptions.Options = nil
					service.TaskTemplate.ContainerSpec.Mounts[i] = mount
				}
			}
		}
	}
	if versions.LessThan(cliVersion, "1.40") {
		if service.TaskTemplate.ContainerSpec != nil {
			// Sysctls for docker swarm services weren't supported before
			// API version 1.40
			service.TaskTemplate.ContainerSpec.Sysctls = nil

			if service.TaskTemplate.ContainerSpec.Privileges != nil && service.TaskTemplate.ContainerSpec.Privileges.CredentialSpec != nil {
				// Support for setting credential-spec through configs was added in API 1.40
				service.TaskTemplate.ContainerSpec.Privileges.CredentialSpec.Config = ""
			}
			for _, config := range service.TaskTemplate.ContainerSpec.Configs {
				// support for the Runtime target was added in API 1.40
				config.Runtime = nil
			}
		}

		if service.TaskTemplate.Placement != nil {
			// MaxReplicas for docker swarm services weren't supported before
			// API version 1.40
			service.TaskTemplate.Placement.MaxReplicas = 0
		}
	}
	if versions.LessThan(cliVersion, "1.41") {
		if service.TaskTemplate.ContainerSpec != nil {
			// Capabilities and Ulimits for docker swarm services weren't
			// supported before API version 1.41
			service.TaskTemplate.ContainerSpec.CapabilityAdd = nil
			service.TaskTemplate.ContainerSpec.CapabilityDrop = nil
			service.TaskTemplate.ContainerSpec.Ulimits = nil
		}
		if service.TaskTemplate.Resources != nil && service.TaskTemplate.Resources.Limits != nil {
			// Limits.Pids  not supported before API version 1.41
			service.TaskTemplate.Resources.Limits.Pids = 0
		}

		// jobs were only introduced in API version 1.41. Nil out both Job
		// modes; if the service is one of these modes and subsequently has no
		// mode, then something down the pipe will thrown an error.
		service.Mode.ReplicatedJob = nil
		service.Mode.GlobalJob = nil
	}

	if versions.LessThan(cliVersion, "1.44") {
		if service.TaskTemplate.ContainerSpec != nil {
			// seccomp, apparmor, and no_new_privs were added in 1.44.
			if service.TaskTemplate.ContainerSpec.Privileges != nil {
				service.TaskTemplate.ContainerSpec.Privileges.Seccomp = nil
				service.TaskTemplate.ContainerSpec.Privileges.AppArmor = nil
				service.TaskTemplate.ContainerSpec.Privileges.NoNewPrivileges = false
			}
			if service.TaskTemplate.ContainerSpec.Healthcheck != nil {
				// StartInterval was added in API 1.44
				service.TaskTemplate.ContainerSpec.Healthcheck.StartInterval = 0
			}
		}
	}

	if versions.LessThan(cliVersion, "1.46") {
		if service.TaskTemplate.ContainerSpec != nil && service.TaskTemplate.ContainerSpec.OomScoreAdj != 0 {
			// OomScoreAdj was added in API 1.46
			service.TaskTemplate.ContainerSpec.OomScoreAdj = 0
		}
	}
}
