// ParseSubscribeResponseAndCallUnsubscribe will parse the response on the go channel.
// It will check the subscribe connection status and when connected
// it will initiate the unsubscribe request.
func ParseSubscribeResponseAndCallUnsubscribe(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, message string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			message = "'" + channel + "' " + message
			//messageAbort := "'" + channel + "' aborted"
			//fmt.Printf("response:",response);
			//fmt.Printf("message:", message);

			if strings.Contains(response, message) {
				returnUnsubscribeChannel := make(chan []byte)
				errorChannel := make(chan []byte)

				go pubnubInstance.Unsubscribe(channel, returnUnsubscribeChannel, errorChannel)
				go ParseUnsubscribeResponse(returnUnsubscribeChannel, channel, "unsubscribed", responseChannel)
				go ParseResponseDummy(errorChannel)

				break
			} /*else if (strings.Contains(response, messageAbort)){
			      responseChannel <- "Test unsubscribed: failed."
			      break
			  } else {
			      responseChannel <- "Test unsubscribed: failed."
			      break
			  }*/
		}
	}
}

func ParseSetUserStateResponseJSON(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, key1 string, val1 string, key2 string, val2 string, jsonString string, testName string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			//fmt.Println("Test JSON'" + testName + "':" +response)
			jsonString = fmt.Sprintf("{\"%s\": \"%s\", \"%s\": \"%s\"}", key2, val2, key1, val1)
			if strings.Contains(response, jsonString) {
				errorChannel := make(chan []byte)
				returnChannel2 := make(chan []byte)
				time.Sleep(3 * time.Second)

				go pubnubInstance.SetUserStateKeyVal(channel, key2, "", returnChannel2, errorChannel)
				go ParseUserStateResponse(returnChannel2, channel, key1, val1, testName, responseChannel)
				go ParseErrorResponse(errorChannel, responseChannel)

				break
			} else {
				responseChannel <- "Test '" + testName + "': failed."
				break
			}
		}
	}
}

// PublishSimpleMessage publises a message on a pubnub channel and
// calls the parse method to validate the message subscription.
func PublishSimpleMessage(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, testName string, cipherKey string, responseChannel chan string) {
	message := "Test message"

	returnChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	go pubnubInstance.Publish(channel, message, returnChannel, errorChannel)
	go ParseSubscribeResponse(pubnubInstance, returnChannel, t, channel, "", testName, cipherKey, responseChannel)
	go ParseErrorResponse(errorChannel, responseChannel)
}

func populateGroup(pubnub *messaging.Pubnub, group, channels string) {
	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	pubnub.ChannelGroupAddChannel(group, channels, successChannel, errorChannel)

	select {
	case <-successChannel:
	case <-errorChannel:
	}
}

func CommonUserStateJSON(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, key1 string, val1 string, key2 string, val2 string, testName string) {
	returnChannel := make(chan []byte)
	errorChannel := make(chan []byte)
	waitChannel := make(chan string)
	responseChannel := make(chan string)

	jsonString := fmt.Sprintf("{\"%s\": \"%s\",\"%s\": \"%s\"}", key1, val1, key2, val2)
	time.Sleep(2 * time.Second)
	go pubnubInstance.SetUserStateJSON(channel, jsonString, returnChannel, errorChannel)
	go ParseSetUserStateResponseJSON(pubnubInstance, returnChannel, channel, key1, val1, key2, val2, jsonString, testName, responseChannel)
	go ParseErrorResponse(errorChannel, responseChannel)
	go WaitForCompletion(responseChannel, waitChannel)
	ParseWaitResponse(waitChannel, t, testName)
}

func populateChannelGroup(pubnub *messaging.Pubnub, group, channels string) {

	successChannel := make(chan []byte, 1)
	errorChannel := make(chan []byte, 1)

	pubnub.ChannelGroupAddChannel(group, channels, successChannel, errorChannel)

	select {
	case <-successChannel:
		// fmt.Println("Group created")
	case <-errorChannel:
		fmt.Println("Channel group creation error")
	case <-timeout():
		fmt.Println("Channel group creation timeout")
	}
}

func createChannelGroups(pubnub *messaging.Pubnub, groups []string) {
	successChannel := make(chan []byte, 1)
	errorChannel := make(chan []byte, 1)

	for _, group := range groups {
		// fmt.Println("Creating group", group)

		pubnub.ChannelGroupAddChannel(group, "adsf", successChannel, errorChannel)

		select {
		case <-successChannel:
			// fmt.Println("Group created")
		case <-errorChannel:
			fmt.Println("Channel group creation error")
		case <-timeout():
			fmt.Println("Channel group creation timeout")
		}
	}
}

func removeChannelGroups(pubnub *messaging.Pubnub, groups []string) {
	successChannel := make(chan []byte, 1)
	errorChannel := make(chan []byte, 1)

	for _, group := range groups {
		// fmt.Println("Removing group", group)

		pubnub.ChannelGroupRemoveGroup(group, successChannel, errorChannel)

		select {
		case <-successChannel:
			// fmt.Println("Group removed")
		case <-errorChannel:
			fmt.Println("Channel group removal error")
		case <-timeout():
			fmt.Println("Channel group removal timeout")
		}
	}
}

// PublishMessages calls the publish method of messaging package numberOfMessages times
// and appends the count with the message to distinguish from the others.
//
// Parameters:
// pubnubInstance: a reference of *messaging.Pubnub,
// channel: the pubnub channel to publish the messages,
// t: a reference to *testing.T,
// startMessagesFrom: the message identifer,
// numberOfMessages: number of messages to send,
// message: message to send.
//
// returns a bool if the publish of all messages is successful.
func PublishMessages(pubnubInstance *messaging.Pubnub, channel string, t *testing.T, startMessagesFrom int, numberOfMessages int, message string) bool {
	messagesReceived := 0
	messageToSend := ""
	tOut := messaging.GetNonSubscribeTimeout()
	messaging.SetNonSubscribeTimeout(30)
	for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ {
		messageToSend = message + strconv.Itoa(i)

		returnPublishChannel := make(chan []byte)
		errorChannel := make(chan []byte)
		go pubnubInstance.Publish(channel, messageToSend, returnPublishChannel, errorChannel)
		messagesReceived++
		//time.Sleep(500 * time.Millisecond)
		time.Sleep(1500 * time.Millisecond)
	}
	if messagesReceived == numberOfMessages {
		return true
	}
	messaging.SetNonSubscribeTimeout(tOut)
	return false
}

func ParseSetUserStateResponse(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, channel string, key string, val string, testName string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			//fmt.Println("Test '" + testName + "':" +response)
			message := fmt.Sprintf("{\"%s\": \"%s\"}", key, val)
			//fmt.Println("%s", message)
			if strings.Contains(response, message) {
				errorChannel := make(chan []byte)
				returnChannel2 := make(chan []byte)
				time.Sleep(3 * time.Second)

				if testName == "SetGetUserState" {
					go pubnubInstance.GetUserState(channel, returnChannel2, errorChannel)
				} else if testName == "SetGetUserStateHereNow" {
					go pubnubInstance.HereNow(channel, true, true, returnChannel2, errorChannel)
				} else if testName == "SetGetUserStateGlobalHereNow" {
					go pubnubInstance.GlobalHereNow(true, true, returnChannel2, errorChannel)
				}
				go ParseUserStateResponse(returnChannel2, channel, key, val, testName, responseChannel)
				go ParseErrorResponse(errorChannel, responseChannel)

				break
			} else {
				responseChannel <- "Test '" + testName + "': failed."
				break
			}
		}
	}
}

func (stock *Stock) UpdateValuesAndPublish(pubnub *messaging.Pubnub,
	cycle chan bool) {
	if stock.CurrentPrice == 0 {
		stock.CurrentPrice = stock.InitialPrice
	}

	rand.Seed(int64(time.Now().Nanosecond()))

	change := float64(rand.Intn(stock.Volatility)-stock.Volatility/2) / 100
	stock.CurrentPrice = stock.CurrentPrice + float64(change)
	delta := stock.CurrentPrice - stock.InitialPrice
	percentage := Roundn((1-stock.InitialPrice/stock.CurrentPrice)*100, 2)
	vol := Randn(stock.Volatility, 1000) * 10

	streamMessage := StreamMessage{
		Time:       time.Now().Format(TIME_FORMAT),
		Price:      fmt.Sprintf("%.2f", stock.CurrentPrice),
		Delta:      fmt.Sprintf("%.2f", delta),
		Percentage: fmt.Sprintf("%.2f", percentage),
		Vol:        vol}

	if math.Abs(percentage) > float64(stock.MaxDelta)/100 {
		stock.CurrentPrice = stock.InitialPrice
	}

	errorChannel := make(chan []byte)
	successChannel := make(chan []byte)
	done := make(chan bool)

	go pubnub.Publish(stock.Name, streamMessage, successChannel, errorChannel)
	go handleResponse(successChannel, errorChannel,
		messaging.GetNonSubscribeTimeout(), done)

	sleep := Randn(stock.MinTrade, stock.MaxTrade)
	time.Sleep(time.Duration(sleep) * time.Microsecond)

	cycle <- <-done
}

func ParseSubcribeResponseForUserState(pubnubInstance *messaging.Pubnub, t *testing.T, returnChannel chan []byte, channel string, key string, val string, testName string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			message := "'" + channel + "' connected"
			messageReconn := "'" + channel + "' reconnected"
			if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
				time.Sleep(1 * time.Second)
				errorChannel := make(chan []byte)
				returnChannel2 := make(chan []byte)

				go pubnubInstance.SetUserStateKeyVal(channel, key, val, returnChannel2, errorChannel)
				go ParseSetUserStateResponse(pubnubInstance, returnChannel2, channel, key, val, testName, responseChannel)
				go ParseErrorResponse(errorChannel, responseChannel)
			}
			break
		}
	}
}

// PublishMessages calls the publish method of messaging package numberOfMessages times
// and appends the count with the message to distinguish from the others.
//
// Parameters:
// pubnubInstance: a reference of *messaging.Pubnub,
// channel: the pubnub channel to publish the messages,
// t: a reference to *testing.T,
// startMessagesFrom: the message identifer,
// numberOfMessages: number of messages to send,
// message: message to send.
//
// returns a bool if the publish of all messages is successful.
func PublishMessages(pubnubInstance *messaging.Pubnub, channel string,
	t *testing.T, startMessagesFrom int, numberOfMessages int,
	message string, sleep func(int)) bool {

	assert := assert.New(t)
	messagesReceived := 0
	messageToSend := ""
	tOut := messaging.GetNonSubscribeTimeout()
	messaging.SetNonSubscribeTimeout(30)

	successChannel := make(chan []byte)
	errorChannel := make(chan []byte)

	for i := startMessagesFrom; i < startMessagesFrom+numberOfMessages; i++ {
		messageToSend = message + strconv.Itoa(i)

		go pubnubInstance.Publish(channel, messageToSend, successChannel, errorChannel)
		select {
		case <-successChannel:
			messagesReceived++
		case err := <-errorChannel:
			assert.Fail("Failed to get channel list", string(err))
		case <-messaging.Timeout():
			assert.Fail("WhereNow timeout")
		}
	}

	sleep(3)
	if messagesReceived == numberOfMessages {
		return true
	}

	messaging.SetNonSubscribeTimeout(tOut)

	return false
}

func CommonUserState(pubnubInstance *messaging.Pubnub, t *testing.T, channel string, key string, val string, testName string) {
	returnSubscribeChannel := make(chan []byte)
	errorChannel := make(chan []byte)
	waitChannel := make(chan string)
	//returnChannel := make(chan []byte)
	responseChannel := make(chan string)

	go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel, false, errorChannel)
	go ParseSubcribeResponseForUserState(pubnubInstance, t, returnSubscribeChannel, channel, key, val, testName, responseChannel)
	go ParseResponseDummy(errorChannel)
	//go ParseErrorResponse(errorChannel, responseChannel)
	go WaitForCompletion(responseChannel, waitChannel)
	ParseWaitResponse(waitChannel, t, testName)
	go pubnubInstance.Unsubscribe(channel, returnSubscribeChannel, errorChannel)
	pubnubInstance.CloseExistingConnection()
	time.Sleep(2 * time.Second)
}

// ParseSubscribeMultiplexedResponse publishes 2 messages on 2 different channels and
// when both the channels are connected
// it reads the responseChannel for the 2 messages. If we get the same 2 messages as response
// the test is passed.
//
// parameters:
// pubnubInstance: an instace of *messaging.Pubnub,
// returnSubscribeChannel: the channel to read the subscribe response on.
// message1: first message to publish.
// message2: second message to publish.
// pubnubChannel1: pubnub Channel 1 to publish the first message.
// pubnubChannel2: pubnub Channel 2 to publish the second message.
// testName: test name.
// responseChannel: the channelto send a response back.
func ParseSubscribeMultiplexedResponse(pubnubInstance *messaging.Pubnub, returnSubscribeChannel chan []byte, message1 string, message2 string, pubnubChannel1 string, pubnubChannel2 string, testName string, responseChannel chan string) {
	messageCount := 0
	channelCount := 0
	for {
		value, ok := <-returnSubscribeChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			message := "' connected"
			messageT1 := "'" + pubnubChannel1 + "' connected"
			messageT2 := "'" + pubnubChannel2 + "' connected"
			if strings.Contains(response, message) {
				if strings.Contains(response, messageT1) {
					channelCount++
				}

				if strings.Contains(response, messageT2) {
					channelCount++
				}
				if channelCount >= 2 {
					returnPublishChannel := make(chan []byte)
					errorChannelPub := make(chan []byte)

					go pubnubInstance.Publish(pubnubChannel1, message1, returnPublishChannel, errorChannelPub)
					go ParseResponseDummy(returnPublishChannel)
					go ParseResponseDummy(errorChannelPub)

					returnPublishChannel2 := make(chan []byte)
					errorChannelPub2 := make(chan []byte)

					go pubnubInstance.Publish(pubnubChannel2, message2, returnPublishChannel2, errorChannelPub2)
					go ParseResponseDummy(returnPublishChannel2)
					go ParseResponseDummy(errorChannelPub2)
				}
			} else {
				var s []interface{}
				err := json.Unmarshal(value, &s)
				if err == nil {
					if len(s) > 2 {
						if message, ok := s[0].([]interface{}); ok {
							if messageT, ok2 := message[0].(string); ok2 {
								if (len(message) > 0) && (messageT == message1) && (s[2].(string) == pubnubChannel1) {
									messageCount++
								}
								if (len(message) > 0) && (messageT == message2) && (s[2].(string) == pubnubChannel2) {
									messageCount++
								}
							}
						}
					}
				}

				if messageCount >= 2 {
					responseChannel <- "Test '" + testName + "': passed."
					break
				}
			}
		}
	}
}

// ParseSubscribeResponse reads the response from the go channel and unmarshal's it.
// It is used by multiple test cases and acts according to the testcase names.
// The idea is to parse each message in the response based on the type of message
// and test against the sent message. If both match the test case is successful.
// _publishSuccessMessage is defined in the common.go file.
func ParseSubscribeResponse(pubnubInstance *messaging.Pubnub, returnChannel chan []byte, t *testing.T, channel string, message string, testName string, cipherKey string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		if string(value) != "[]" {
			response := fmt.Sprintf("%s", value)
			//fmt.Println("Response1:", response)
			if (testName == "SubscriptionConnectedForComplex") || (testName == "SubscriptionConnectedForComplexWithCipher") {
				message = "'" + channel + "' connected"
				if strings.Contains(response, message) {
					PublishComplexMessage(pubnubInstance, t, channel, publishSuccessMessage, cipherKey, responseChannel)
				} else {
					//fmt.Println("resp:", response)
					if ParseSubscribeData(t, value, testName, cipherKey, responseChannel) {
						responseChannel <- "Test '" + testName + "': passed."
					} else {
						responseChannel <- "Test '" + testName + "': failed."
					}
					break
				}
			} else if (testName == "SubscriptionConnectedForSimple") || (testName == "SubscriptionConnectedForSimpleWithCipher") {
				message = "'" + channel + "' connected"
				if strings.Contains(response, message) {
					PublishSimpleMessage(pubnubInstance, t, channel, publishSuccessMessage, cipherKey, responseChannel)
				} else {
					if ParseSubscribeData(t, value, testName, cipherKey, responseChannel) {
						responseChannel <- "Test '" + testName + "': passed."
					} else {
						responseChannel <- "Test '" + testName + "': failed."
					}
					break
				}
			} else if testName == "SubscriptionAlreadySubscribed" {
				message = "'" + channel + "' connected"

				if strings.Contains(response, message) {
					returnSubscribeChannel2 := make(chan []byte)
					errorChannel2 := make(chan []byte)

					go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel2, false, errorChannel2)
					go ParseSubscribeResponse(pubnubInstance, errorChannel2, t, channel, "already subscribed", "SubscriptionAlreadySubscribedResponse", "", responseChannel)
					go ParseResponseDummy(returnSubscribeChannel2)
				}
				break
			} else if testName == "SubscriptionAlreadySubscribedResponse" {
				message = "'" + channel + "' already subscribed"
				if strings.Contains(response, message) {
					responseChannel <- "Test '" + testName + "': passed."
				} else {
					responseChannel <- "Test '" + testName + "': failed."
					//t.Error("Test '" + testName + "': failed.");
				}
				break
			} else if testName == "SubscriptionConnectStatus" {
				message = "'" + channel + "' connected"
				if strings.Contains(response, message) {
					responseChannel <- "Test '" + testName + "': passed."
				} else {
					responseChannel <- "Test '" + testName + "': failed."
					//t.Error("Test '" + testName + "': failed.");
				}
				break
			}
		}
	}
}

// ParseSubscribeResponseForPresence will look for the connection status in the response
// received on the go channel.
func ParseSubscribeResponseForPresence(pubnubInstance *messaging.Pubnub, customUuid string, returnChannel chan []byte, channel string, testName string, responseChannel chan string) {
	for {
		value, ok := <-returnChannel
		if !ok {
			break
		}
		//response := fmt.Sprintf("%s", value)
		//fmt.Println(response);

		if string(value) != "[]" {
			if (testName == "CustomUuid") || (testName == "HereNow") || (testName == "HereNowWithCipher") {
				response := fmt.Sprintf("%s", value)
				message := "'" + channel + "' connected"
				messageReconn := "'" + channel + "' reconnected"
				if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
					errorChannel := make(chan []byte)
					returnChannel := make(chan []byte)
					time.Sleep(3 * time.Second)
					go pubnubInstance.HereNow(channel, true, true, returnChannel, errorChannel)
					go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
					go ParseErrorResponse(errorChannel, responseChannel)
					break
				}
			} else if testName == "WhereNow" {
				response := fmt.Sprintf("%s", value)
				message := "'" + channel + "' connected"
				messageReconn := "'" + channel + "' reconnected"
				if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
					errorChannel := make(chan []byte)
					returnChannel := make(chan []byte)
					time.Sleep(3 * time.Second)
					go pubnubInstance.WhereNow(customUuid, returnChannel, errorChannel)
					go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
					go ParseErrorResponse(errorChannel, responseChannel)
					break
				}
			} else if testName == "GlobalHereNow" {
				response := fmt.Sprintf("%s", value)
				message := "'" + channel + "' connected"
				messageReconn := "'" + channel + "' reconnected"
				if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {
					errorChannel := make(chan []byte)
					returnChannel := make(chan []byte)
					time.Sleep(3 * time.Second)
					go pubnubInstance.GlobalHereNow(true, false, returnChannel, errorChannel)
					go ParseHereNowResponse(returnChannel, channel, customUuid, testName, responseChannel)
					go ParseErrorResponse(errorChannel, responseChannel)
					break
				}
			} else {
				response := fmt.Sprintf("%s", value)
				message := "'" + channel + "' connected"
				messageReconn := "'" + channel + "' reconnected"
				//fmt.Println("Test3 '" + testName + "':" +response)
				if (strings.Contains(response, message)) || (strings.Contains(response, messageReconn)) {

					errorChannel2 := make(chan []byte)
					returnSubscribeChannel := make(chan []byte)
					time.Sleep(1 * time.Second)
					go pubnubInstance.Subscribe(channel, "", returnSubscribeChannel, false, errorChannel2)
					go ParseResponseDummy(returnSubscribeChannel)
					go ParseResponseDummy(errorChannel2)
				} else {
					if testName == "Presence" {
						data, _, returnedChannel, err2 := messaging.ParseJSON(value, "")

						var occupants []struct {
							Action    string
							Uuid      string
							Timestamp float64
							Occupancy int
						}

						if err2 != nil {
							responseChannel <- "Test '" + testName + "': failed. Message: 1 :" + err2.Error()
							break
						}
						//fmt.Println("Test3 '" + testName + "':" +data)
						err := json.Unmarshal([]byte(data), &occupants)
						if err != nil {
							//fmt.Println("err '" + testName + "':",err)
							responseChannel <- "Test '" + testName + "': failed. Message: 2 :" + err.Error()
							break
						} else {
							channelSubRepsonseReceived := false
							for i := 0; i < len(occupants); i++ {
								if (occupants[i].Action == "join") && occupants[i].Uuid == customUuid {
									channelSubRepsonseReceived = true
									break
								}
							}
							if !channelSubRepsonseReceived {
								responseChannel <- "Test '" + testName + "': failed. Message: err3"
								break
							}
							if channel == returnedChannel {
								responseChannel <- "Test '" + testName + "': passed."
								break
//.........这里部分代码省略.........

// GetServerTime calls the GetTime method of the messaging, parses the response to get the
// value and return it.
func GetServerTime(pubnubInstance *messaging.Pubnub, t *testing.T, testName string) int64 {
	returnTimeChannel := make(chan []byte)
	errorChannel := make(chan []byte)
	go pubnubInstance.GetTime(returnTimeChannel, errorChannel)
	return ParseServerTimeResponse(returnTimeChannel, t, testName)
}