// Send a request using the supplied authentication tokens.
// Returns an ApiResult that needsto be checked for errors and messages.
func (self *Client) SendApiRequest(url, description string) *ApiResult {
	apiResult := &ApiResult{}
	apiResult.QueryDescription = description
	apiResult.Error = false

	r, _ := http.NewRequest("GET", url, nil)
	r.SetBasicAuth(self.username, self.apikey)

	httpResponse, httpError := self.client.Do(r)
	if httpError != nil {
		apiResult.HttpError = httpError
		return apiResult
	}

	apiResult.StatusCode = httpResponse.StatusCode
	apiResult.Status = httpResponse.Status

	jsonResponse, jsonError := jason.NewObjectFromReader(httpResponse.Body)
	if jsonError != nil {
		apiResult.JsonError = jsonError
		return apiResult
	}
	apiResult.Json = jsonResponse
	httpResponse.Body.Close()

	obj, notFoundError := jsonResponse.GetObject("error")
	if notFoundError == nil {
		apiResult.Error = true
		apiResult.ErrorMessage = jasonGetString(obj, "message")
		apiResult.DeveloperMessage = jasonGetString(obj, "developer_message")
	}

	return apiResult
}

// CheckAPIKey performs a test API call with the API key
// provided in the configuration file to determine if the
// service should be enabled.
func (yt *YouTube) CheckAPIKey() error {
	var (
		response *http.Response
		v        *jason.Object
		err      error
	)

	if viper.GetString("api_keys.youtube") == "" {
		return errors.New("No YouTube API key has been provided")
	}
	url := "https://www.googleapis.com/youtube/v3/videos?part=snippet&id=KQY9zrjPBjo&key=%s"
	response, err = http.Get(fmt.Sprintf(url, viper.GetString("api_keys.youtube")))
	defer response.Body.Close()
	if err != nil {
		return err
	}

	if v, err = jason.NewObjectFromReader(response.Body); err != nil {
		return err
	}

	if v, err = v.GetObject("error"); err == nil {
		message, _ := v.GetString("message")
		code, _ := v.GetInt64("code")
		errArray, _ := v.GetObjectArray("errors")
		reason, _ := errArray[0].GetString("reason")

		return fmt.Errorf("%d: %s (reason: %s)", code, message, reason)
	}
	return nil
}

func LoadDevices() (devices map[int]*Device, categories map[int]*Category, rooms map[int]*Room) {
	res, _ := goreq.Request{
		Uri: "http://10.0.1.61:3480/data_request?id=sdata&output_format=json",
	}.Do()
	json_response, _ := jason.NewObjectFromReader(res.Response.Body)
	categories_json, _ := json_response.GetObjectArray("categories")
	devices_json, _ := json_response.GetObjectArray("devices")
	rooms_json, _ := json_response.GetObjectArray("rooms")

	devices = make(map[int]*Device)
	categories = make(map[int]*Category)
	rooms = make(map[int]*Room)
	for _, room_json := range rooms_json {
		room := new(Room)
		room_bytes, _ := room_json.Marshal()
		json.Unmarshal(room_bytes, &room)
		rooms[room.Id] = room
	}
	for _, category_json := range categories_json {
		category := new(Category)
		category_bytes, _ := category_json.Marshal()
		json.Unmarshal(category_bytes, &category)
		categories[category.Id] = category
	}
	for _, device_json := range devices_json {
		device := new(Device)
		device_bytes, _ := device_json.Marshal()
		json.Unmarshal(device_bytes, &device)
		device.RoomName = rooms[device.Room].Name
		device.CategoryName = categories[device.Category].Name
		devices[device.Id] = device
	}

	return devices, categories, rooms
}

func (ia *itemAttributes) GetItemInfo() (*jason.Object, error) {

	var path = ia.bendoServer + "/item/" + ia.item

	req, _ := http.NewRequest("GET", path, nil)
	if ia.token != "" {
		req.Header.Add("X-Api-Key", ia.token)
	}
	r, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer r.Body.Close()
	if r.StatusCode != 200 {
		switch r.StatusCode {
		case 404:
			return nil, ErrNotFound
		case 401:
			return nil, ErrNotAuthorized
		default:
			return nil, fmt.Errorf("Received status %d from Bendo", r.StatusCode)
		}
	}

	v, err := jason.NewObjectFromReader(r.Body)

	return v, err
}

func (ia *itemAttributes) getUploadMeta(fileId string) (*jason.Object, error) {

	var path = ia.bendoServer + "/upload/" + fileId + "/metadata"

	req, _ := http.NewRequest("GET", path, nil)
	if ia.token != "" {
		req.Header.Add("X-Api-Key", ia.token)
	}
	req.Header.Add("Accept-Encoding", "application/json")
	r, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer r.Body.Close()
	if r.StatusCode != 200 {
		switch r.StatusCode {
		case 404:
			return nil, ErrNotFound
		case 401:
			return nil, ErrNotAuthorized
		default:
			return nil, fmt.Errorf("Received status %d from Bendo", r.StatusCode)
		}
	}

	v, err := jason.NewObjectFromReader(r.Body)

	return v, err
}

func (ia *itemAttributes) getTransactionStatus(transaction string) (*jason.Object, error) {
	var path = ia.bendoServer + "/transaction/" + transaction

	req, err := http.NewRequest("GET", path, nil)

	if err != nil {
		return nil, err
	}

	req.Header.Set("Accept-Encoding", "application/json")
	if ia.token != "" {
		req.Header.Add("X-Api-Key", ia.token)
	}

	resp, err := http.DefaultClient.Do(req)
	defer resp.Body.Close()

	if err != nil {
		return nil, err
	}
	if resp.StatusCode != 200 {
		switch resp.StatusCode {
		case 404:
			return nil, ErrNotFound
		case 401:
			return nil, ErrNotAuthorized
		default:
			return nil, fmt.Errorf("Received status %d from Bendo", resp.StatusCode)
		}
	}

	v, err := jason.NewObjectFromReader(resp.Body)

	return v, err
}

// GetTracks uses the passed URL to find and return
// tracks associated with the URL. An error is returned
// if any error occurs during the API call.
func (mc *Mixcloud) GetTracks(url string, submitter *gumble.User) ([]interfaces.Track, error) {
	var (
		apiURL string
		err    error
		resp   *http.Response
		v      *jason.Object
		tracks []interfaces.Track
	)

	apiURL = strings.Replace(url, "www", "api", 1)

	// Track playback offset is not present in Mixcloud URLs,
	// so we can safely assume that users will not request
	// a playback offset in the URL.
	offset, _ := time.ParseDuration("0s")

	resp, err = http.Get(apiURL)
	defer resp.Body.Close()
	if err != nil {
		return nil, err
	}

	v, err = jason.NewObjectFromReader(resp.Body)
	if err != nil {
		return nil, err
	}

	id, _ := v.GetString("slug")
	trackURL, _ := v.GetString("url")
	title, _ := v.GetString("name")
	author, _ := v.GetString("user", "username")
	authorURL, _ := v.GetString("user", "url")
	durationSecs, _ := v.GetInt64("audio_length")
	duration, _ := time.ParseDuration(fmt.Sprintf("%ds", durationSecs))
	thumbnail, err := v.GetString("pictures", "large")
	if err != nil {
		// Track has no artwork, using profile avatar instead.
		thumbnail, _ = v.GetString("user", "pictures", "large")
	}

	track := bot.Track{
		ID:             id,
		URL:            trackURL,
		Title:          title,
		Author:         author,
		AuthorURL:      authorURL,
		Submitter:      submitter.Name,
		Service:        mc.ReadableName,
		ThumbnailURL:   thumbnail,
		Filename:       id + ".track",
		Duration:       duration,
		PlaybackOffset: offset,
		Playlist:       nil,
	}

	tracks = append(tracks, track)

	return tracks, nil
}

func Add(rend render.Render, req *http.Request) {
	params, _ := jason.NewObjectFromReader(req.Body)
	name, _ := params.GetString("name")
	result, err := group.Add(name)
	if err != nil {
		rend.JSON(200, helper.Error(err))
		return
	}
	rend.JSON(200, helper.Success(result))
}

func YandexTrans(yandexID, in string) string {
	escapedIn := url.QueryEscape(in)
	retry := 0
Req:
	var to string
	from := YandexDetect(ydTransAPI, in)
	if from == "zh" {
		to = "en"
	} else {
		to = "zh"
	}
	res, err := goreq.Request{
		Uri: fmt.Sprintf("https://translate.yandex.net"+
			"/api/v1.5/tr.json/translate?"+
			"key=%s&lang=%s&text=%s",
			yandexID, to, escapedIn),
		Timeout: 17 * time.Second,
	}.Do()
	if err != nil {
		if retry < 2 {
			retry++
			goto Req
		} else {
			log.Println("Translation Timeout!")
			return "群组娘连接母舰失败，请稍后重试"
		}
	}

	jasonObj, _ := jason.NewObjectFromReader(res.Body)
	code, _ := jasonObj.GetInt64("code")
	switch code {
	case 200:
		text, _ := jasonObj.GetStringArray("text")
		return strings.Join(text, "\n")
	case 401: //未授权用户
		return "大概男盆友用错API Key啦，大家快去蛤他！σ`∀´)`"
	case 402: //API被屏蔽
		return "可怜的群组娘被母舰放逐了X﹏X"
	case 403, 404: //请求次数已用完
		return "今天弹药不足，明天再来吧(＃°Д°)"
	case 413: //文本太长
		return "警报！弹药系统过载！请放宽后重试"
	case 422: //文本不可翻译
		return "咦？这是外星语喵？"
	case 501: //不支持的语种
		return "恭喜你触发了母舰的迷之G点"
	default:
		return "发生了理论上不可能出现的错误，你是不是穿越了喵？"
	}
}

func Check(rend render.Render, req *http.Request) {
	body, _ := jason.NewObjectFromReader(req.Body)
	clientsId, _ := body.GetInt64Array("clientsId")
	clientList := client.List(clientsId)
	results := JSON.Type{}
	for _, c := range clientList {
		result, err := c.CallRpc("CheckDeployPath", rpc.CheckDeployPathArgs{c.Id, c.DeployPath})
		if err != nil {
			results[helper.Itoa64(c.Id)] = helper.Error(err)
		} else {
			results[helper.Itoa64(c.Id)] = result
		}
	}
	rend.JSON(200, helper.Success(results))
}

func (expvars *Expvars) Fetch(addr string) error {
	resp, err := expvars.client.Get(addr)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode == http.StatusNotFound {
		return errors.New("not found")
	}
	expvars.Object, err = jason.NewObjectFromReader(resp.Body)
	if err != nil {
		return err
	}
	return nil
}

func BaiduTranslate(apiKey, in string) (out, from string) {
	in = url.QueryEscape(in)
	retry := 0
Req:
	res, err := goreq.Request{
		Uri: fmt.Sprintf("http://openapi.baidu.com/public/2.0/bmt/translate?"+
			"client_id=%s&q=%s&from=auto&to=auto",
			apiKey, in),
		Timeout: 17 * time.Second,
	}.Do()
	if err != nil {
		if retry < 2 {
			retry++
			goto Req
		} else {
			log.Println("Translation Timeout!")
			return "群组娘连接母舰失败，请稍后重试", ""
		}
	}

	jasonObj, _ := jason.NewObjectFromReader(res.Body)
	from, _ = jasonObj.GetString("from")
	result, err := jasonObj.GetObjectArray("trans_result")
	if err != nil {
		errCode, _ := jasonObj.GetString("error_code")
		switch errCode {
		case "52001": //超时
			return "转换失败，母舰大概是快没油了Orz", ""
		case "52002": //翻译系统错误
			return "母舰崩坏中...", ""
		case "52003": //未授权用户
			return "大概男盆友用错API Key啦，大家快去蛤他！σ`∀´)`", ""
		case "52004": //必填参数为空
			return "弹药装填系统泄漏，一定不是奴家的锅(╯‵□′)╯", ""
		default:
			return "发生了理论上不可能出现的错误，你是不是穿越了喵？", ""
		}
	}

	var outs []string
	for k := range result {
		tmp, _ := result[k].GetString("dst")
		outs = append(outs, tmp)
	}
	out = strings.Join(outs, "\n")
	return out, from
}

func RemoveBackup(rend render.Render, req *http.Request, params martini.Params) {
	id := helper.Int64(params["id"])
	host, errResponse := getClientWithAliveOrJSONError(id)
	if host == nil {
		rend.JSON(200, errResponse)
		return
	}

	body, _ := jason.NewObjectFromReader(req.Body)
	path, _ := body.GetString("path")

	_, err := host.RemoveBackup(path)
	if err != nil {
		rend.JSON(200, helper.Error(err))
		return
	}
	rend.JSON(200, helper.Success())
}

func (yt *YouTube) getTrack(id string, submitter *gumble.User, offset time.Duration) (bot.Track, error) {
	var (
		resp *http.Response
		err  error
		v    *jason.Object
	)

	videoURL := "https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails&id=%s&key=%s"
	resp, err = http.Get(fmt.Sprintf(videoURL, id, viper.GetString("api_keys.youtube")))
	defer resp.Body.Close()
	if err != nil {
		return bot.Track{}, err
	}

	v, err = jason.NewObjectFromReader(resp.Body)
	if err != nil {
		return bot.Track{}, err
	}
	items, _ := v.GetObjectArray("items")
	if len(items) == 0 {
		return bot.Track{}, errors.New("This YouTube video is private")
	}
	item := items[0]
	title, _ := item.GetString("snippet", "title")
	thumbnail, _ := item.GetString("snippet", "thumbnails", "high", "url")
	author, _ := item.GetString("snippet", "channelTitle")
	durationString, _ := item.GetString("contentDetails", "duration")
	durationConverted, _ := duration.FromString(durationString)
	duration := durationConverted.ToDuration()

	return bot.Track{
		ID:             id,
		URL:            "https://youtube.com/watch?v=" + id,
		Title:          title,
		Author:         author,
		Submitter:      submitter.Name,
		Service:        yt.ReadableName,
		Filename:       id + ".track",
		ThumbnailURL:   thumbnail,
		Duration:       duration,
		PlaybackOffset: offset,
		Playlist:       nil,
	}, nil
}

func ShortUrl(url string) string {
	res, err := goreq.Request{
		Uri: fmt.Sprintf(
			"http://is.gd/create.php?format=json&url=%s",
			url),
		Timeout: 3 * time.Second,
	}.Do()
	if err != nil {
		loge.Warning("Short Failed!")
		return url
	}
	jasonObj, err := jason.NewObjectFromReader(res.Body)
	if err != nil {
		return url
	}
	s, err := jasonObj.GetString("shorturl")
	if err != nil {
		e, _ := jasonObj.GetString("errormessage")
		loge.Warning(e)
		return url
	}
	return s
}

//Create  issue from a reader
func (j Jira) Create(reader io.Reader) (i IssueEvent, err error) {
	v, err := jason.NewObjectFromReader(reader)
	if err != nil {
		return i, nil
	}

	user, _ := v.GetString("user", "name")
	userurl, _ := v.GetString("user", "avatarUrls", "24x24")
	summary, _ := v.GetString("issue", "fields", "summary")
	event, _ := v.GetString("webhookEvent")
	id, _ := v.GetString("issue", "id")
	url, _ := v.GetString("issue", "self")
	pname, _ := v.GetString("issue", "fields", "project", "name")
	items, err := v.GetObjectArray("changelog", "items")
	changes := make(map[string]string)
	for _, item := range items {
		field, _ := item.GetString("field")
		value, _ := item.GetString("toString")
		changes[field] = value
	}

	i = IssueEvent{Event: event, User: user, Userurl: userurl, ID: id, URL: url, Summary: summary, Project: strings.ToLower(pname), Changes: changes}
	return i, nil
}

// Check using key
func Check(organizer, project, now, key string) (string, error) {
	api := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", organizer, project)
	res, err := http.Get(api)
	if err != nil {
		return "", errors.Wrap(err, "failed to get request: "+api)
	}
	defer res.Body.Close()

	json, err := jason.NewObjectFromReader(res.Body)
	if err != nil {
		return "", errors.Wrap(err, "failed to parse json")
	}

	isnew, err := json.GetString(key)
	if err != nil {
		return "", errors.Wrap(err, "failed to get value related to version from json")
	}

	if version.Compare(now, isnew, "<") {
		return fmt.Sprintf("update available. version: %s", isnew), nil
	}

	return fmt.Sprintf("update not available."), nil
}

func YandexDetect(yandexID, in string) string {
	in = url.QueryEscape(in)
	retry := 0
Req:
	res, err := goreq.Request{
		Uri: fmt.Sprintf("https://translate.yandex.net/api/v1.5/tr.json/detect?"+
			"key=%s&text=%s",
			yandexID, in),
		Timeout: 17 * time.Second,
	}.Do()
	if err != nil {
		if retry < 2 {
			retry++
			goto Req
		} else {
			log.Println("Translation Timeout!")
			return "群组娘连接母舰失败，请稍后重试"
		}
	}

	jasonObj, _ := jason.NewObjectFromReader(res.Body)
	code, _ := jasonObj.GetInt64("code")
	switch code {
	case 200:
		lang, _ := jasonObj.GetString("lang")
		return lang
	case 401: //未授权用户
		return "大概男盆友用错API Key啦，大家快去蛤他！σ`∀´)`"
	case 402:
		return "可怜的群组娘被母舰放逐了X﹏X"
	case 403, 404: //请求次数已用完
		return "今天弹药不足，明天再来吧(＃°Д°)"
	default:
		return "发生了理论上不可能出现的错误，你是不是穿越了喵？"
	}
}

// ParseExpvar parses expvar data from reader.
func ParseExpvar(r io.Reader) (*Expvar, error) {
	object, err := jason.NewObjectFromReader(r)
	return &Expvar{object}, err
}

				}
			}
			`)

			req.Body(payload)
			res := DoRequest(req)
			Expect(res.StatusCode).To(Equal(200))

			getReq := sling.New().Get(hoverflyAdminUrl + "/api/v2/simulation")

			getRes := DoRequest(getReq)
			Expect(getRes.StatusCode).To(Equal(200))

			defer getRes.Body.Close()

			schemaObject, err := jason.NewObjectFromReader(getRes.Body)
			Expect(err).To(BeNil())

			dataObject, err := schemaObject.GetObject("data")
			Expect(err).To(BeNil())

			pairsArray, err := dataObject.GetObjectArray("pairs")
			Expect(err).To(BeNil())

			Expect(pairsArray).To(HaveLen(1))

			requestObject, err := pairsArray[0].GetObject("request")
			Expect(err).To(BeNil())

			requestType, err := requestObject.GetString("requestType")
			Expect(err).To(BeNil())