package daemon

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"syscall"

	"github.com/docker/docker/archive"
	"github.com/docker/docker/daemon/execdriver"
	"github.com/docker/docker/pkg/symlink"
)

type Volume struct {
	HostPath    string
	VolPath     string
	Mode        string
	isBindMount bool
}

func (v *Volume) isRw() bool {
	return v.Mode == "" || strings.ToLower(v.Mode) == "rw"
}

func (v *Volume) isDir() (bool, error) {
	stat, err := os.Stat(v.HostPath)
	if err != nil {
		return false, err
	}

	return stat.IsDir(), nil
}

func prepareVolumesForContainer(container *Container) error {
	if container.Volumes == nil || len(container.Volumes) == 0 {
		container.Volumes = make(map[string]string)
		container.VolumesRW = make(map[string]bool)
		if err := applyVolumesFrom(container); err != nil {
			return err
		}
	}

	if err := createVolumes(container); err != nil {
		return err
	}
	return nil
}

func setupMountsForContainer(container *Container) error {
	mounts := []execdriver.Mount{
		{container.ResolvConfPath, "/etc/resolv.conf", true, true},
	}

	if container.HostnamePath != "" {
		mounts = append(mounts, execdriver.Mount{container.HostnamePath, "/etc/hostname", true, true})
	}

	if container.HostsPath != "" {
		mounts = append(mounts, execdriver.Mount{container.HostsPath, "/etc/hosts", true, true})
	}

	secretsPath, err := container.secretsPath()
	if err != nil {
		return err
	}

	mounts = append(mounts, execdriver.Mount{secretsPath, "/run/secrets", true, true})

	// Mount user specified volumes
	// Note, these are not private because you may want propagation of (un)mounts from host
	// volumes. For instance if you use -v /usr:/usr and the host later mounts /usr/share you
	// want this new mount in the container
	for r, v := range container.Volumes {
		mounts = append(mounts, execdriver.Mount{v, r, container.VolumesRW[r], false})
	}

	container.command.Mounts = mounts

	return nil
}

func applyVolumesFrom(container *Container) error {
	volumesFrom := container.hostConfig.VolumesFrom
	if len(volumesFrom) > 0 {
		for _, containerSpec := range volumesFrom {
			var (
				mountRW   = true
				specParts = strings.SplitN(containerSpec, ":", 2)
			)

			switch len(specParts) {
			case 0:
				return fmt.Errorf("Malformed volumes-from specification: %s", containerSpec)
			case 2:
				switch specParts[1] {
				case "ro":
					mountRW = false
				case "rw": // mountRW is already true
				default:
					return fmt.Errorf("Malformed volumes-from specification: %s", containerSpec)
				}
			}

			c := container.daemon.Get(specParts[0])
			if c == nil {
				return fmt.Errorf("Container %s not found. Impossible to mount its volumes", specParts[0])
			}

			if err := c.Mount(); err != nil {
				return fmt.Errorf("Container %s failed to mount. Impossible to mount its volumes", specParts[0])
			}
			defer c.Unmount()

			for volPath, id := range c.Volumes {
				if _, exists := container.Volumes[volPath]; exists {
					continue
				}

				pth, err := c.getResourcePath(volPath)
				if err != nil {
					return err
				}

				stat, err := os.Stat(pth)
				if err != nil {
					return err
				}

				if err := createIfNotExists(pth, stat.IsDir()); err != nil {
					return err
				}

				container.Volumes[volPath] = id
				if isRW, exists := c.VolumesRW[volPath]; exists {
					container.VolumesRW[volPath] = isRW && mountRW
				}
			}

		}
	}
	return nil
}

func parseBindVolumeSpec(spec string) (Volume, error) {
	var (
		arr = strings.Split(spec, ":")
		vol Volume
	)

	vol.isBindMount = true
	switch len(arr) {
	case 1:
		vol.VolPath = spec
		vol.Mode = "rw"
	case 2:
		vol.HostPath = arr[0]
		vol.VolPath = arr[1]
		vol.Mode = "rw"
	case 3:
		vol.HostPath = arr[0]
		vol.VolPath = arr[1]
		vol.Mode = arr[2]
	default:
		return vol, fmt.Errorf("Invalid volume specification: %s", spec)
	}

	if !filepath.IsAbs(vol.HostPath) {
		return vol, fmt.Errorf("cannot bind mount volume: %s volume paths must be absolute.", vol.HostPath)
	}

	return vol, nil
}

func getBindMap(container *Container) (map[string]Volume, error) {
	var (
		// Create the requested bind mounts
		volumes = map[string]Volume{}
		// Define illegal container destinations
		illegalDsts = []string{"/", "."}
	)

	for _, bind := range container.hostConfig.Binds {
		vol, err := parseBindVolumeSpec(bind)
		if err != nil {
			return volumes, err
		}
		// Bail if trying to mount to an illegal destination
		for _, illegal := range illegalDsts {
			if vol.VolPath == illegal {
				return nil, fmt.Errorf("Illegal bind destination: %s", vol.VolPath)
			}
		}

		volumes[filepath.Clean(vol.VolPath)] = vol
	}
	return volumes, nil
}

func createVolumes(container *Container) error {
	// Get all the bindmounts
	volumes, err := getBindMap(container)
	if err != nil {
		return err
	}

	// Get all the rest of the volumes
	for volPath := range container.Config.Volumes {
		// Make sure the the volume isn't already specified as a bindmount
		if _, exists := volumes[volPath]; !exists {
			volumes[volPath] = Volume{
				VolPath:     volPath,
				Mode:        "rw",
				isBindMount: false,
			}
		}
	}

	for _, vol := range volumes {
		if err = vol.initialize(container); err != nil {
			return err
		}
	}
	return nil

}

func createVolumeHostPath(container *Container) (string, error) {
	volumesDriver := container.daemon.volumes.Driver()

	// Do not pass a container as the parameter for the volume creation.
	// The graph driver using the container's information ( Image ) to
	// create the parent.
	c, err := container.daemon.volumes.Create(nil, "", "", "", "", nil, nil)
	if err != nil {
		return "", err
	}
	hostPath, err := volumesDriver.Get(c.ID, "")
	if err != nil {
		return hostPath, fmt.Errorf("Driver %s failed to get volume rootfs %s: %s", volumesDriver, c.ID, err)
	}

	return hostPath, nil
}

func (v *Volume) initialize(container *Container) error {
	var err error
	v.VolPath = filepath.Clean(v.VolPath)

	// Do not initialize an existing volume
	if _, exists := container.Volumes[v.VolPath]; exists {
		return nil
	}

	// If it's not a bindmount we need to create the dir on the host
	if !v.isBindMount {
		v.HostPath, err = createVolumeHostPath(container)
		if err != nil {
			return err
		}
	}

	hostPath, err := filepath.EvalSymlinks(v.HostPath)
	if err != nil {
		return err
	}

	// Create the mountpoint
	// This is the path to the volume within the container FS
	// This differs from `hostPath` in that `hostPath` refers to the place where
	// the volume data is actually stored on the host
	fullVolPath, err := symlink.FollowSymlinkInScope(filepath.Join(container.basefs, v.VolPath), container.basefs)
	if err != nil {
		return err
	}

	container.Volumes[v.VolPath] = hostPath
	container.VolumesRW[v.VolPath] = v.isRw()

	volIsDir, err := v.isDir()
	if err != nil {
		return err
	}
	if err := createIfNotExists(fullVolPath, volIsDir); err != nil {
		return err
	}

	// Do not copy or change permissions if we are mounting from the host
	if v.isRw() && !v.isBindMount {
		return copyExistingContents(fullVolPath, hostPath)
	}
	return nil
}

func createIfNotExists(destination string, isDir bool) error {
	if _, err := os.Stat(destination); err == nil || !os.IsNotExist(err) {
		return nil
	}

	if isDir {
		return os.MkdirAll(destination, 0755)
	}

	if err := os.MkdirAll(filepath.Dir(destination), 0755); err != nil {
		return err
	}

	f, err := os.OpenFile(destination, os.O_CREATE, 0755)
	if err != nil {
		return err
	}
	f.Close()

	return nil
}

func copyExistingContents(source, destination string) error {
	volList, err := ioutil.ReadDir(source)
	if err != nil {
		return err
	}

	if len(volList) > 0 {
		srcList, err := ioutil.ReadDir(destination)
		if err != nil {
			return err
		}

		if len(srcList) == 0 {
			// If the source volume is empty copy files from the root into the volume
			if err := archive.CopyWithTar(source, destination); err != nil {
				return err
			}
		}
	}

	return copyOwnership(source, destination)
}

// copyOwnership copies the permissions and uid:gid of the source file
// into the destination file
func copyOwnership(source, destination string) error {
	var stat syscall.Stat_t

	if err := syscall.Stat(source, &stat); err != nil {
		return err
	}

	if err := os.Chown(destination, int(stat.Uid), int(stat.Gid)); err != nil {
		return err
	}

	return os.Chmod(destination, os.FileMode(stat.Mode))
}
