// AddDir adds a directory to be watched, returning an error if any.
// It allows a filter to be specified on which files to watch.
// It also allows recursive watching.
func (fw *FileSystemWatcher) AddDir(path, pattern string, ops Op, recursive bool) error {

	// Add the given path to be watched. addDir will perform checking for us to
	// ensure that the path really is a directory.
	err := fw.addDir(path, pattern, ops)
	if err != nil {
		return stackerr.Wrap(err)
	}

	if recursive {
		err = filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
			if info.IsDir() {
				// Subdirectories inherit the filename pattern and ops from the parent.
				if e := fw.addDir(p, pattern, ops); err != nil {
					return stackerr.Wrap(e)
				}
			}
			return nil
		})
		if err != nil {
			return err
		}
	}

	return nil
}

func (l *login) updatedNetrcContent(
	e *env,
	content io.Reader,
	credentials *credentials,
) ([]byte, error) {
	tokens, err := netrc.Parse(content)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	server, err := getHostFromURL(e.Server)
	if err != nil {
		return nil, err
	}
	machine := tokens.FindMachine(server)
	if machine == nil {
		machine = tokens.NewMachine(server, "default", credentials.token, "")
	} else {
		machine.UpdatePassword(credentials.token)
	}

	updatedContent, err := tokens.MarshalText()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return updatedContent, nil
}

func (l *logsCmd) round(e *env, c *context, startTime *parseTime) (*parseTime, error) {
	v := make(url.Values)
	v.Set("n", fmt.Sprint(l.num))
	v.Set("level", l.level)

	if startTime != nil {
		b, err := json.Marshal(startTime)
		if err != nil {
			return nil, stackerr.Wrap(err)
		}
		v.Set("startTime", string(b))
	}

	u := &url.URL{
		Path:     "scriptlog",
		RawQuery: v.Encode(),
	}
	var rows []logResponse
	if _, err := e.ParseAPIClient.Get(u, &rows); err != nil {
		return nil, stackerr.Wrap(err)
	}
	// logs come back in reverse
	for i := len(rows) - 1; i >= 0; i-- {
		fmt.Fprintln(e.Out, rows[i].Message)
	}
	if len(rows) > 0 {
		return &rows[0].Timestamp, nil
	}
	return startTime, nil
}

func (h *functionHooksCmd) functionHooksCreate(e *parsecli.Env, ctx *parsecli.Context) error {
	params, err := readFunctionParams(e, h.Function)
	if err != nil {
		return err
	}

	var res functionHook
	functionsURL, err := url.Parse(defaultFunctionsURL)
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Post(functionsURL, params, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}

	fmt.Fprintf(e.Out,
		"Successfully created a webhook function %q pointing to %q\n",
		res.FunctionName,
		res.URL,
	)
	return nil
}

func writeProjectConfig(p *projectConfig, path string) error {
	b, err := json.MarshalIndent(p, "", "  ")
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(ioutil.WriteFile(path, b, 0600))
}

func (s *UserService) create(req *restful.Request, resp *restful.Response) {
	// TODO (m0sth8): Check permissions
	raw := &user.User{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}

	mgr := s.Manager()
	defer mgr.Close()

	obj, err := mgr.Users.Create(raw)
	if err != nil {
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.NewError(services.CodeDuplicate, "user with this email is existed"))
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}

	resp.WriteHeader(http.StatusCreated)
	resp.WriteEntity(obj)
}

func (h *functionHooksCmd) functionHooksUpdate(e *parsecli.Env, ctx *parsecli.Context) error {
	params, err := readFunctionParams(e, h.Function)
	if err != nil {
		return err
	}
	var res functionHook
	functionsURL, err := url.Parse(path.Join(defaultFunctionsURL, params.FunctionName))
	if err != nil {
		return stackerr.Wrap(err)
	}

	_, err = e.ParseAPIClient.Put(functionsURL, &functionHook{URL: params.URL}, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}

	fmt.Fprintf(e.Out,
		"Successfully update the webhook function %q to point to %q\n",
		res.FunctionName,
		res.URL,
	)
	return nil
}

func (h *triggerHooksCmd) triggerHooksUpdate(e *env, ctx *context) error {
	params, err := readTriggerParams(e, h.Trigger)
	if err != nil {
		return err
	}
	var res triggerHook
	triggersURL, err := url.Parse(path.Join(defaultTriggersURL, params.ClassName, params.TriggerName))
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Put(triggersURL, &triggerHook{URL: params.URL}, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}
	fmt.Fprintf(e.Out,
		"Successfully update the %q trigger for class %q to point to %q\n",
		res.TriggerName,
		res.ClassName,
		res.URL,
	)

	return nil
}

func (h *triggerHooksCmd) triggerHooksDelete(e *env, ctx *context) error {
	params, err := readTriggerName(e, h.Trigger)
	if err != nil {
		return err
	}
	triggersURL, err := url.Parse(path.Join(defaultTriggersURL, params.ClassName, params.TriggerName))
	if err != nil {
		return stackerr.Wrap(err)
	}

	confirmMessage := fmt.Sprintf("Are you sure you want to delete %q webhook trigger for class: %q (y/n): ",
		params.TriggerName,
		params.ClassName,
	)

	var res triggerHook
	if !h.interactive || getConfirmation(confirmMessage, e) {
		_, err = e.ParseAPIClient.Put(triggersURL, map[string]interface{}{"__op": "Delete"}, &res)
		if err != nil {
			return stackerr.Wrap(err)
		}
		fmt.Fprintf(e.Out, "Successfully deleted %q webhook trigger for class %q\n",
			params.TriggerName,
			params.ClassName,
		)
		if res.TriggerName != "" && res.ClassName != "" {
			fmt.Fprintf(e.Out, "%q trigger defined in cloudcode for class %q will be used henceforth\n",
				res.TriggerName,
				res.ClassName,
			)
		}
	}
	return nil
}

// BestEfforDockerClient creates a docker client from one of:
//
// 1. Environment variables as defined in
//    https://docs.docker.com/reference/commandline/cli/. Specifically
//    DOCKER_HOST, DOCKER_TLS_VERIFY & DOCKER_CERT_PATH.
//
// 2. bootdocker, if darwin.
//
// 3. /run/docker.sock, if it exists.
//
// 4. /var/run/docker.sock, if it exists.
func BestEffortDockerClient() (*dockerclient.DockerClient, error) {
	host := os.Getenv("DOCKER_HOST")

	if host == "" {
		if runtime.GOOS == "darwin" {
			return Boot2DockerClient()
		}

		socketLocations := []string{"/run/docker.sock", "/var/run/docker.sock"}
		for _, l := range socketLocations {
			if _, err := os.Stat(l); err == nil {
				c, err := dockerclient.NewDockerClient(fmt.Sprintf("unix://%s", l), nil)
				if err != nil {
					return nil, stackerr.Wrap(err)
				}
				return c, nil
			}
		}

		return nil, stackerr.New("docker not configured")
	}

	if os.Getenv("DOCKER_TLS_VERIFY") != "" {
		return DockerWithTLS(host, os.Getenv("DOCKER_CERT_PATH"))
	}

	c, err := dockerclient.NewDockerClient(host, nil)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	return c, nil
}

// DockerWithTLS returns a DockerClient with the certs in the specified
// directory. The names of the certs are the standard names of "cert.pem",
// "key.pem" and "ca.pem".
func DockerWithTLS(url, certPath string) (*dockerclient.DockerClient, error) {
	var tlsConfig *tls.Config
	clientCert, err := tls.LoadX509KeyPair(
		filepath.Join(certPath, "cert.pem"),
		filepath.Join(certPath, "key.pem"),
	)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	rootCAs := x509.NewCertPool()
	caCert, err := ioutil.ReadFile(filepath.Join(certPath, "ca.pem"))
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	rootCAs.AppendCertsFromPEM(caCert)

	tlsConfig = &tls.Config{
		Certificates: []tls.Certificate{clientCert},
		RootCAs:      rootCAs,
	}
	client, err := dockerclient.NewDockerClient(url, tlsConfig)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return client, nil
}

// disabled
func (s *ScanService) update(req *restful.Request, resp *restful.Response, pl *scan.Scan) {
	// TODO (m0sth8): Check permissions
	// TODO (m0sth8): Forbid changes in scan after finished status

	raw := &scan.Scan{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}
	mgr := s.Manager()
	defer mgr.Close()

	raw.Id = pl.Id

	if err := mgr.Scans.Update(raw); err != nil {
		if mgr.IsNotFound(err) {
			resp.WriteErrorString(http.StatusNotFound, "Not found")
			return
		}
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.NewError(services.CodeDuplicate, "scan with this name and version is existed"))
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}

	resp.WriteHeader(http.StatusOK)
	resp.WriteEntity(raw)
}

// create file with data
func (m *FileManager) Create(r io.Reader, metaInfo *file.Meta) (*file.Meta, error) {
	f, err := m.grid.Create("")
	// according to gridfs code, the error here is impossible
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	size, err := io.Copy(f, r)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	meta := &file.Meta{
		Id:          file.UniqueFileId(),
		Size:        int(size),
		ContentType: metaInfo.ContentType,
		Name:        metaInfo.Name,
	}
	f.SetId(meta.Id)
	f.SetMeta(meta)
	if meta.ContentType != "" {
		f.SetContentType(meta.ContentType)
	}
	if err = f.Close(); err != nil {
		return nil, stackerr.Wrap(err)
	}
	return meta, nil
}

func (c *configureCmd) deleteHook(
	e *env,
	hooksOps []*hookOperation,
	fields ...string,
) (bool, []*hookOperation, error) {
	restOp := strings.ToUpper(fields[0])
	if restOp != "DELETE" {
		return false, nil, stackerr.Wrap(errInvalidFormat)
	}

	switch len(fields) {
	case 2:
		hooksOps = append(hooksOps, &hookOperation{
			method:   "DELETE",
			function: &functionHook{FunctionName: fields[1]},
		})
		return true, hooksOps, nil
	case 3:
		if err := c.checkTriggerName(fields[2]); err != nil {
			return false, nil, err
		}
		hooksOps = append(hooksOps, &hookOperation{
			method:  "DELETE",
			trigger: &triggerHook{ClassName: fields[1], TriggerName: fields[2]},
		})
		return true, hooksOps, nil
	}

	return false, nil, stackerr.Wrap(errInvalidFormat)
}

func send(s mangos.Socket, obj interface{}) error {
	data, err := json.Marshal(obj)
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(s.Send(data))
}

func (h *triggerHooksCmd) triggerHooksCreate(e *env, ctx *context) error {
	params, err := readTriggerParams(e, h.Trigger)
	if err != nil {
		return err
	}
	var res triggerHook
	triggersURL, err := url.Parse(defaultTriggersURL)
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Post(triggersURL, params, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}
	fmt.Fprintf(e.Out,
		"Successfully created a %q trigger for class %q pointing to %q\n",
		res.TriggerName,
		res.ClassName,
		res.URL,
	)
	return nil
}

func recv(s mangos.Socket, obj interface{}) error {
	data, err := s.Recv()
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(json.Unmarshal(data, obj))
}

func (g *Generator) genForNames(names string) error {
	certFileName := "cert.pem"
	keyFileName := "key.pem"

	rootCert, err := g.loadRootCA()
	if err != nil {
		return err
	}

	rootKey, err := g.loadRootCAKey()
	if err != nil {
		return err
	}

	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return stackerr.Wrap(err)
	}

	now := time.Now()

	template := x509.Certificate{
		SerialNumber: new(big.Int).SetInt64(0),
		Subject: pkix.Name{
			CommonName: names,
		},
		NotBefore:             now.Add(-5 * time.Minute).UTC(),
		NotAfter:              now.Add(g.MaxAge),
		SubjectKeyId:          []byte{1, 2, 3, 4},
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
		BasicConstraintsValid: true,
	}

	derBytes, err := x509.CreateCertificate(
		rand.Reader, &template, rootCert, &priv.PublicKey, rootKey)
	if err != nil {
		return stackerr.Wrap(err)
	}

	certOut, err := os.Create(certFileName)
	if err != nil {
		return stackerr.Wrap(err)
	}
	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
	certOut.Close()
	log.Print("Written " + certFileName + "\n")

	keyOut, err := os.OpenFile(keyFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		return stackerr.Wrap(err)
	}
	pem.Encode(keyOut, &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(priv),
	})
	keyOut.Close()
	log.Print("Written " + keyFileName + "\n")
	return nil
	return nil
}

func (d *downloadCmd) run(e *env, c *context) error {
	var err error

	latestRelease := d.release
	if latestRelease == nil {
		latestRelease, err = (&deployCmd{}).getPrevDeplInfo(e)
		if err != nil {
			return err
		}
		if len(latestRelease.Versions.Cloud) == 0 && len(latestRelease.Versions.Public) == 0 {
			return errNoFiles
		}
	}

	destination := d.destination
	if destination == "" {
		destination, err = ioutil.TempDir("", "parse_code_")
		if err != nil {
			return stackerr.Wrap(err)
		}
	}

	err = d.download(e, destination, latestRelease)
	if err != nil {
		fmt.Fprintln(e.Err, "Failed to download Cloud Code.")
		return stackerr.Wrap(err)
	}
	if !d.force {
		fmt.Fprintf(e.Out, "Successfully downloaded Cloud Code to %q.\n", destination)
		return nil
	}

	return stackerr.Wrap(d.moveFiles(e, destination, latestRelease))
}

func (i *iosSymbolUploader) convertSymbols(e *env) ([]string, error) {
	homedir, err := homedir.Dir()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	folderPath := filepath.Join(homedir, ".parse", "CrashReportingSymbols")
	if err := i.prepareSymbolsFolder(folderPath, e); err != nil {
		return nil, stackerr.Wrap(err)
	}

	conversionTool, err := i.symbolConversionTool(homedir, nil, e)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	cmd := exec.Command(conversionTool, i.Path, folderPath)
	if out, err := cmd.CombinedOutput(); err != nil {
		return nil, stackerr.Newf("Symbol conversion failed with:\n%s", string(out))
	}

	filenames, err := readDirNames(folderPath)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return filenames, nil
}