//Copyright 2017 Huawei Technologies Co., Ltd
//
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
package rest

import (
	"encoding/json"
	pb "github.com/ServiceComb/service-center/server/core/proto"
	"github.com/ServiceComb/service-center/util"
	"github.com/ServiceComb/service-center/util/rest"
	"io/ioutil"
	"net/http"
	"strings"
)

type MicroServiceService struct {
	//
}

func (this *MicroServiceService) URLPatterns() []rest.Route {
	return []rest.Route{
		{rest.HTTP_METHOD_GET, "/registry/v3/existence", this.GetExistence},
		{rest.HTTP_METHOD_GET, "/registry/v3/microservices", this.GetServices},
		{rest.HTTP_METHOD_GET, "/registry/v3/microservices/:serviceId", this.GetServiceOne},
		{rest.HTTP_METHOD_POST, "/registry/v3/microservices", this.Register},
		{rest.HTTP_METHOD_PUT, "/registry/v3/microservices/:serviceId/properties", this.Update},
		{rest.HTTP_METHOD_DELETE, "/registry/v3/microservices/:serviceId", this.Unregister},
		{rest.HTTP_METHOD_GET, "/registry/v3/microservices/:serviceId/schemas/:schemaId", this.GetSchemas},
		{rest.HTTP_METHOD_PUT, "/registry/v3/microservices/:serviceId/schemas/:schemaId", this.ModifySchemas},
		{rest.HTTP_METHOD_DELETE, "/registry/v3/microservices/:serviceId/schemas/:schemaId", this.DeleteSchemas},

		{rest.HTTP_METHOD_PUT, "/registry/v3/dependencies", this.CreateDependenciesForMicroServices},
		{rest.HTTP_METHOD_GET, "/registry/v3/microservices/:consumerId/providers", this.GetConProDependencies},
		{rest.HTTP_METHOD_GET, "/registry/v3/microservices/:providerId/consumers", this.GetProConDependencies},
		{rest.HTTP_METHOD_DELETE, "/registry/v3/microservices", this.UnregisterServices},
	}
}

func (this *MicroServiceService) GetSchemas(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetSchemaRequest{
		ServiceId: r.URL.Query().Get(":serviceId"),
		SchemaId:  r.URL.Query().Get(":schemaId"),
	}
	resp, err := ServiceAPI.GetSchemaInfo(r.Context(), request)
	if len(resp.Schema) != 0 {
		resp.Response = nil
		WriteJsonObject(http.StatusOK, resp, w)
		return
	}
	WriteTextResponse(resp.GetResponse(), err, "", w)
}

func (this *MicroServiceService) ModifySchemas(w http.ResponseWriter, r *http.Request) {
	message, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LOGGER.Error("body err", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	request := &pb.ModifySchemaRequest{
		ServiceId: r.URL.Query().Get(":serviceId"),
		SchemaId:  r.URL.Query().Get(":schemaId"),
	}
	err = json.Unmarshal(message, request)
	if err != nil {
		util.LOGGER.Error("Unmarshal error", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	resp, err := ServiceAPI.ModifySchema(r.Context(), request)
	WriteTextResponse(resp.GetResponse(), err, "", w)
}

func (this *MicroServiceService) DeleteSchemas(w http.ResponseWriter, r *http.Request) {
	request := &pb.DeleteSchemaRequest{
		ServiceId: r.URL.Query().Get(":serviceId"),
		SchemaId:  r.URL.Query().Get(":schemaId"),
	}
	resp, err := ServiceAPI.DeleteSchema(r.Context(), request)
	WriteTextResponse(resp.GetResponse(), err, "", w)
}

func (this *MicroServiceService) Register(w http.ResponseWriter, r *http.Request) {
	message, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LOGGER.Error("body err", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	var request pb.CreateServiceRequest
	err = json.Unmarshal(message, &request)
	if err != nil {
		util.LOGGER.Error("Unmarshal error", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	resp, err := ServiceAPI.Create(r.Context(), &request)
	if err != nil {
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	if resp.GetResponse().Code != pb.Response_SUCCESS {
		WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) Update(w http.ResponseWriter, r *http.Request) {
	message, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LOGGER.Error("body err", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	request := &pb.UpdateServicePropsRequest{
		ServiceId: r.URL.Query().Get(":serviceId"),
	}
	err = json.Unmarshal(message, request)
	if err != nil {
		util.LOGGER.Error("Unmarshal error", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	resp, err := ServiceAPI.UpdateProperties(r.Context(), request)
	WriteTextResponse(resp.GetResponse(), err, "", w)
}

func (this *MicroServiceService) Unregister(w http.ResponseWriter, r *http.Request) {
	force := r.URL.Query().Get("force")
	serviceId := r.URL.Query().Get(":serviceId")
	util.LOGGER.Warnf(nil, "Service %s unregists, force is %s.", serviceId, force)
	if force != "0" && force != "1" && strings.TrimSpace(force) != "" {
		WriteText(http.StatusBadRequest, "parameter force must be 1 or 0", w)
		return
	}
	request := &pb.DeleteServiceRequest{
		ServiceId: serviceId,
		Force:     force == "1",
	}
	resp, err := ServiceAPI.Delete(r.Context(), request)
	WriteTextResponse(resp.GetResponse(), err, "", w)
}

func (this *MicroServiceService) GetServices(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetServicesRequest{}
	util.LOGGER.Debugf("tenant is %s", r.Context().Value("tenant").(string))
	resp, err := ServiceAPI.GetServices(r.Context(), request)
	if err != nil {
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	if resp.GetResponse().Code != pb.Response_SUCCESS {
		WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) GetExistence(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetExistenceRequest{
		Type:        r.URL.Query().Get("type"),
		AppId:       r.URL.Query().Get("appId"),
		ServiceName: r.URL.Query().Get("serviceName"),
		Version:     r.URL.Query().Get("version"),
		ServiceId:   r.URL.Query().Get("serviceId"),
		SchemaId:    r.URL.Query().Get("schemaId"),
	}
	resp, err := ServiceAPI.Exist(r.Context(), request)
	if err != nil {
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	if resp.GetResponse().Code != pb.Response_SUCCESS {
		WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) GetServiceOne(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetServiceRequest{
		ServiceId: r.URL.Query().Get(":serviceId"),
	}
	resp, err := ServiceAPI.GetOne(r.Context(), request)
	if err != nil {
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	if resp.GetResponse().Code != pb.Response_SUCCESS {
		WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) CreateDependenciesForMicroServices(w http.ResponseWriter, r *http.Request) {
	requestBody, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LOGGER.Error("body err", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}
	request := &pb.CreateDependenciesRequest{}
	err = json.Unmarshal(requestBody, request)
	if err != nil {
		util.LOGGER.Error("Unmarshal error", err)
		WriteText(http.StatusInternalServerError, "Unmarshal error", w)
		return
	}
	//fmt.Println("request is ", request)
	rsp, err := ServiceAPI.CreateDependenciesForMircServices(r.Context(), request)
	//fmt.Println("rsp is ", rsp)
	//请求错误
	if err != nil {
		util.LOGGER.Errorf(err, "create dependency failed for service internal reason.")
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	//服务内部错误
	if rsp.Response.Code == pb.Response_FAIL {
		util.LOGGER.Errorf(nil, "create dependency failed for request invalid. %s", rsp.Response.Message)
		WriteText(http.StatusBadRequest, rsp.Response.Message, w)
		return
	}
	WriteText(http.StatusOK, "add dependency success.", w)
}

func (this *MicroServiceService) GetConProDependencies(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetDependenciesRequest{
		ServiceId: r.URL.Query().Get(":consumerId"),
	}
	resp, err := ServiceAPI.GetConsumerDependencies(r.Context(), request)
	if err != nil {
		util.LOGGER.Error("get Dependency failed.", err)
		WriteText(http.StatusInternalServerError, "get Dependency failed", w)
		return
	}
	//服务请求错误
	if resp.Response.Code == pb.Response_FAIL {
		util.LOGGER.Errorf(nil, resp.Response.Message)
		WriteText(http.StatusBadRequest, resp.Response.Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) GetProConDependencies(w http.ResponseWriter, r *http.Request) {
	request := &pb.GetDependenciesRequest{
		ServiceId: r.URL.Query().Get(":providerId"),
	}
	resp, err := ServiceAPI.GetProviderDependencies(r.Context(), request)
	if err != nil {
		util.LOGGER.Error("get Dependency failed.", err)
		WriteText(http.StatusInternalServerError, "get Dependency failed", w)
		return
	}
	//服务请求错误
	if resp.Response.Code == pb.Response_FAIL {
		util.LOGGER.Errorf(nil, resp.Response.Message)
		WriteText(http.StatusBadRequest, resp.Response.Message, w)
		return
	}
	resp.Response = nil
	WriteJsonObject(http.StatusOK, resp, w)
}

func (this *MicroServiceService) UnregisterServices(w http.ResponseWriter, r *http.Request) {
	request_body,err := ioutil.ReadAll(r.Body)
	if err != nil{
		util.LOGGER.Error("body ,err",err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}

	request := &pb.DelServicesRequest{}

	err = json.Unmarshal(request_body, request)
	if err  != nil {
		util.LOGGER.Error("unmarshal ,err ", err)
		WriteText(http.StatusBadRequest, err.Error(), w)
		return
	}

	resp, err := ServiceAPI.DeleteServices(r.Context(), request)

	if resp.Response.Code == pb.Response_SUCCESS {
		WriteText(http.StatusOK, "", w)
		return
	}
	if resp.Services == nil || len(resp.Services) == 0 {
		WriteText(http.StatusBadRequest, resp.Response.Message, w)
		return
	}
	resp.Response = nil
	objJson, err := json.Marshal(resp)
	if err != nil {
		WriteText(http.StatusInternalServerError, err.Error(), w)
		return
	}
	WriteJson(http.StatusBadRequest, objJson, w)
	return
}