package github

import (
	"fmt"
	"net/url"

	"github.com/drone/drone/plugin/remote"
	"github.com/drone/go-github/github"
)

type Client struct {
	config *Github
	access string // user access token
}

// GetUser fetches the user by ID (login name).
func (c *Client) GetUser(login string) (*remote.User, error) {
	return nil, nil
}

// GetRepos fetches all repositories that the specified
// user has access to in the remote system.
func (c *Client) GetRepos(owner string) ([]*remote.Repo, error) {
	// create the github client
	client := github.New(c.access)

	// retrieve a list of all github repositories
	repos, err := client.Repos.ListAll()
	if err != nil {
		return nil, err
	}

	// store results in common format
	result := []*remote.Repo{}

	// parse the hostname from the github url
	githuburl, err := url.Parse(c.config.URL)
	if err != nil {
		return nil, err
	}

	// loop throught the list and convert to the standard repo format
	for _, repo := range repos {
		// if the repository is private we should use the ssh
		// url to clone, else we should use the git url
		if repo.Private {
			repo.CloneUrl = repo.SshUrl
		}

		result = append(result, &remote.Repo{
			ID:      repo.ID,
			Host:    githuburl.Host,
			Owner:   repo.Owner.Login,
			Name:    repo.Name,
			Kind:    "git",
			Clone:   repo.CloneUrl,
			Git:     repo.GitUrl,
			SSH:     repo.SshUrl,
			Private: repo.Private,
			Push:    repo.Permissions.Push,
			Pull:    repo.Permissions.Pull,
			Admin:   repo.Permissions.Admin,
		})
	}

	return result, nil
}

// GetScript fetches the build script (.drone.yml) from the remote
// repository using the GitHub API and returns the raw file in string format.
func (c *Client) GetScript(hook *remote.Hook) (out string, err error) {
	// create the github client
	client := github.New(c.access)

	// retrieve the .drone.yml file from GitHub
	content, err := client.Contents.FindRef(hook.Owner, hook.Repo, ".drone.yml", hook.Sha)
	if err != nil {
		return
	}

	// decode the content
	raw, err := content.DecodeContent()
	if err != nil {
		return
	}

	return string(raw), nil
}

// SetStatus
func (c *Client) SetStatus(owner, name, sha, status string) error {
	// create the github client
	client := github.New(c.access)

	// convert from drone status to github status
	var message string
	switch status {
	case "Success":
		status = "success"
		message = "The build succeeded on drone.io"
	case "Failure":
		status = "failure"
		message = "The build failed on drone.io"
	case "Started", "Pending":
		status = "pending"
		message = "The build is pending on drone.io"
	default:
		status = "error"
		message = "The build errored on drone.io"
	}

	// format the build URL
	// TODO we really need the branch here
	// TODO we really need the drone.io hostname as well
	url := fmt.Sprintf("http://beta.drone.io/%s/%s/%s/%s", owner, name, "master", sha)

	// update the status
	return client.Repos.CreateStatus(owner, name, status, url, message, sha)
}

// SetActive will configure a post-commit and pull-request hook
// with the remote GitHub repository using the GitHub API.
//
// It will also, optionally, add a public RSA key. This is primarily
// used for private repositories, which typically must use the Git+SSH
// protocol to clone the repository.
func (c *Client) SetActive(owner, name, hook, key string) error {
	// create the github client
	client := github.New(c.access)

	// parse the hostname from the hook, and use this
	// to name the ssh key
	hookurl, err := url.Parse(hook)
	if err != nil {
		return err
	}

	// fetch the repository so that we can see if it
	// is public or private.
	repo, err := client.Repos.Find(owner, name)
	if err != nil {
		return err
	}

	// if the repository is private we'll need
	// to upload a github key to the repository
	if repo.Private {
		// name the key
		keyname := "drone@" + hookurl.Host
		_, err := client.RepoKeys.CreateUpdate(owner, name, key, keyname)
		if err != nil {
			return err
		}
	}

	// add the hook
	if _, err := client.Hooks.CreateUpdate(owner, name, hook); err != nil {
		return err
	}

	return nil
}