package common

import (
	"errors"
	"time"
)

//响应
type Response struct {
	Message string
	Ok      bool
}

//请求
type Request struct {
	Name string
}

// HandlerName 提供者的唯一名称
const HandlerName = "Handler.Execute"

//Handler是一个处理器
type Handler struct {
	// Sleep 用于模拟一个耗时的方法执行操作
	Sleep time.Duration
}

// Execute() 是 RPC 客户端可以调用的方法，通过使用 HandlerName 调用 RPC 服务器
// 如果没有错误，则它接受一个请求并产生一个响应发生；如果Sleep不为0，则服务器端和客户端处于休眠状态
func (h *Handler) Execute(req Request, res *Response) (err error) {
	if req.Name == "" {
		err = errors.New("A name must be specified")
		return
	}

	if h.Sleep != 0 {
		time.Sleep(h.Sleep)
	}

	res.Ok = true
	res.Message = "Hello " + req.Name

	return
}

package client

import (
	"context"
	"errors"
	"common"
	"net/rpc"
	"net/rpc/jsonrpc"
	"strconv"
)

// Client 包含以下配置选项与 RPC 服务器通信
type Client struct {
	Port    uint
	UseHttp bool
	UseJson bool
	client  *rpc.Client
}

//Init 初始化底层 RPC 客户端
//负责获取编解码器并编写 RPC服务器
func (c *Client) Init() (err error) {
	if c.Port == 0 {
		err = errors.New("client: port must be specified")
		return
	}

	addr := "127.0.0.1:" + strconv.Itoa(int(c.Port))

	if c.UseHttp {
		c.client, err = rpc.DialHTTP("tcp", addr)
	} else if c.UseJson {
		c.client, err = jsonrpc.Dial("tcp", addr)
	} else {
		c.client, err = rpc.Dial("tcp", addr)
	}
	if err != nil {
		return
	}

	return
}

// Close 优雅地终止底层客户端
func (c *Client) Close() (err error) {
	if c.client != nil {
		err = c.client.Close()
		return
	}

	return
}

// 通过client.Call()方法进行RPC调用
func (c *Client) Execute(ctx context.Context, name string) (msg string, err error) {
	var (
		request  = &common.Request{Name: name}
		response = new(common.Response)
	)

	err = c.client.Call(common.HandlerName, request, response)
	if err != nil {
		return
	}

	msg = response.Message
	return

}

import (
	"context"
	"flag"
	cli "client"
	serv "server"
	"log"
	"os"
	"os/signal"
	"syscall"
)

var (
	port        = flag.Uint("port", 1337, "port to listen or connect to for rpc calls")
	isServer    = flag.Bool("server", false, "activates server mode")
	json        = flag.Bool("json", false, "whether it should use json-rpc")
	serverSleep = flag.Duration("server.sleep", 0, "time for the server to sleep on requests")
	http        = flag.Bool("http", false, "whether it should use HTTP")
)

// handleSignals 是一个等待终止或中断的阻塞函数
func handleSignals() {
	signals := make(chan os.Signal, 1)

	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
	<-signals
	log.Println("signal received")
}

// must 在错误的情况下记录
func must(err error) {
	if err == nil {
		return
	}

	log.Panicln(err)
}

//启动服务器，进行服务器监听
func runServer() {
	server := &serv.Server{
		UseHttp: *http,
		UseJson: *json,
		Sleep:   *serverSleep,
		Port:    *port,
	}
	defer server.Close()

	go func() {
		handleSignals()
		server.Close()
		os.Exit(0)
	}()

	must(server.Start())
	return
}

//解析命令行标志，然后启动客户端执行RPC调用
func runClient() {
	client := &cli.Client{
		UseHttp: *http,
		UseJson: *json,
		Port:    *port,
	}
	defer client.Close()

	must(client.Init())
	var con context.Context

	response, err := client.Execute(con, "Shirdon")
	must(err)

	log.Println(response)
}

func main() {
	flag.Parse()

	if *isServer {
		log.Println("starting server")
		log.Printf("will listen on port %d\n", *port)

		runServer()
		return
	}

	log.Println("starting client")
	log.Printf("will connect to port %d\n", *port)

	runClient()
	return
}

//服务接口提供对字符串的操作
type Service interface {
	UpperString(string) (string, error)
	Reverse(string) string
}

type StringService struct {
	log log.Logger
}

//创建字符串服务
func NewStringService(log log.Logger) *StringService {
	return &StringService{log}
}

//实现UpperString()方法
func (svc *StringService) UpperString(s string) (string, error) {
	reverse := svc.Reverse(s)
	if strings.ToLower(s) == "" {
		return "", errors.New("empty string")
	}
	return strings.ToUpper(reverse), nil
}

//实现Reverse()方法
func (svc *StringService) Reverse(s string) string {
	//转换为 rune
	rns := []rune(s)
	for i, j := 0, len(rns)-1; i < j; i, j = i+1, j-1 {
		// 交换字符串的字母
		rns[i], rns[j] = rns[j], rns[i]
	}

	// 返回反转的字符串
	return strings.ToLower(string(rns))
}

//大写字符串请求
type UpperStringRequest struct {
	Word string `json:"word"`
}

//逆转字符串请求
type ReverseRequest struct {
	Word string `json:"word"`
}

//响应
type UpperStringResponse struct {
	Message string `json:"message"`
}

//逆转字符串响应
type ReverseResponse struct {
	Word string `json:"reversed_word"`
}

//端点
type Endpoints struct {
	GetUpperStringindrome endpoint.Endpoint
	GetReverse            endpoint.Endpoint
}

//创建端点
func MakeEndpoints(svc Service, logger log.Logger,
	middlewares []endpoint.Middleware) Endpoints {
	return Endpoints{
		GetUpperStringindrome: wrapEndpoint(
			makeGetUpperStringindromeEndpoint(svc, logger), middlewares),
		GetReverse: wrapEndpoint(makeGetReverseEndpoint(svc,
			logger), middlewares),
	}
}

//创建获取大写字符串字符串端点
func makeGetUpperStringindromeEndpoint(svc Service,
	logger log.Logger) endpoint.Endpoint {
	return func(ctx context.Context,
		request interface{}) (interface{}, error) {
		req, ok := request.(UpperStringRequest)
		fmt.Println(req)
		if !ok {
			return nil, errors.New("invalid request")
		}
		str, _ := svc.UpperString(req.Word)
		fmt.Println(str)
		return &UpperStringResponse{
			Message: str,
		}, nil
	}

}

//创建获取逆转字符串端点
func makeGetReverseEndpoint(svc Service,
	logger log.Logger) endpoint.Endpoint {
	return func(ctx context.Context,
		request interface{}) (interface{}, error) {
		req, ok := request.(ReverseRequest)
		if !ok {
			return nil, errors.New("invalid request")
		}
		str, _ := svc.UpperString(req.Word)
		return &ReverseResponse{
			Word: str,
		}, nil
	}
}

//打包处理端点
func wrapEndpoint(e endpoint.Endpoint,
	middlewares []endpoint.Middleware) endpoint.Endpoint {
	for _, m := range middlewares {
		e = m(e)
	}
	return e
}

//创建大写字符串控制器
func GetUpperStringHandler(ep endpoint.Endpoint, options []httptransport.ServerOption) *httptransport.Server {
	return httptransport.NewServer(
		ep,
		decodeGetUpperStringRequest,
		encodeGetUpperStringResponse,
		options...,
	)
}

//解码请求
func decodeGetUpperStringRequest(_ context.Context, r *http.Request) (interface{}, error) {
	var req UpperStringRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		return nil, err
	}
	return req, nil
}

//编码响应
func encodeGetUpperStringResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
	resp, ok := response.(*UpperStringResponse)
	if !ok {
		return errors.New("error decoding")
	}
	return json.NewEncoder(w).Encode(resp)
}

//创建逆转控制器
func GetReverseHandler(ep endpoint.Endpoint, options []httptransport.ServerOption) *httptransport.Server {
	return httptransport.NewServer(
		ep,
		decodeGetReverseRequest,
		encodeGetReverseResponse,
		options...,
	)
}

//解码获取逆转字符串请求
func decodeGetReverseRequest(_ context.Context, r *http.Request) (interface{}, error) {
	var req ReverseRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		return nil, err
	}
	return req, nil
}

//编码获取逆转字符串响应
func encodeGetReverseResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
	resp, ok := response.(*ReverseResponse)
	if !ok {
		return errors.New("error decoding")
	}

	return json.NewEncoder(w).Encode(resp)
}

func main() {
	var logger log.Logger
	{
		logger = log.NewLogfmtLogger(os.Stderr)
		logger = log.With(logger, "ts", log.DefaultTimestampUTC)
		logger = log.With(logger, "caller", log.DefaultCaller)
	}

	//声明中间件
	var middlewares []endpoint.Middleware
	//声明服务器可选参数
	var options []httptransport.ServerOption
	//创建一个字符串服务对象
	svc := pkg.NewStringService(logger)
	//创建端点
	eps := pkg.MakeEndpoints(svc, logger, middlewares)
	//创建路由器
	r := mux.NewRouter()
	//指定控制器
	r.Methods(http.MethodGet).Path("/upperstring").
		Handler(pkg.GetUpperStringHandler(eps.GetUpperStringindrome, options))
	r.Methods(http.MethodGet).Path("/reverse").
		Handler(pkg.GetReverseHandler(eps.GetReverse, options))
	level.Info(logger).Log("status", "listening", "port", "8082")
	svr := http.Server{
		Addr:    "127.0.0.1:8082",
		Handler: r,
	}
	level.Error(logger).Log(svr.ListenAndServe())
}

var UserCreated userCreated

// 定义事件所需的有效负载
type UserCreatedPayload struct {
	Email string
	Time  time.Time
}

type userCreated struct {
	handlers []interface{ Handle(UserCreatedPayload) }
}

// 为此事件添加事件处理程序
func (u *userCreated) Register(handler interface {
	Handle(UserCreatedPayload)
}) {
	u.handlers = append(u.handlers, handler)
}

// 触发器发送带有有效负载的事件
func (u userCreated) Trigger(payload UserCreatedPayload) {
	fmt.Println(u.handlers)
	for _, handler := range u.handlers {
		handler.Handle(payload)
	}

}

func Handle(payload UserCreatedPayload) {
	fmt.Println("handle:", payload)
}

var UserCreated userCreated

// 定义事件所需的有效负载
type UserCreatedPayload struct {
	Email string
	Time  time.Time
}

type userCreated struct {
	handlers []interface{ Handle(UserCreatedPayload) }
}

// 为此事件添加事件处理程序
func (u *userCreated) Register(handler interface {
	Handle(UserCreatedPayload)
}) {
	u.handlers = append(u.handlers, handler)
}

// 触发器发送带有有效负载的事件
func (u userCreated) Trigger(payload UserCreatedPayload) {
	fmt.Println(u.handlers)
	for _, handler := range u.handlers {
		handler.Handle(payload)
	}

}

func Handle(payload UserCreatedPayload) {
	fmt.Println("handle:", payload)
}

func init() {
	createNotifier := UserCreatedNotifier{
		AdminEmail: "test1@example.com",
	}

	events.UserCreated.Register(createNotifier)
}

type UserCreatedNotifier struct {
	AdminEmail string
}

func (u UserCreatedNotifier) NotifyAdmin(email string, time time.Time) {
	// 向管理员发送一条消息，说明用户已创建
	fmt.Println("Notify Created Admin Email:", email, time.Unix())
}

func (u UserCreatedNotifier) Handle(payload events.UserCreatedPayload) {
	// 发送消息
	u.NotifyAdmin(payload.Email, payload.Time)
}

func init() {
	deleteNotifier := UserDeletedNotifier{
		AdminEmail: "jack@example.com",
	}

	events.UserDeleted.Register(deleteNotifier)
}

type UserDeletedNotifier struct {
	AdminEmail string
}

func (u UserDeletedNotifier) NotifyAdmin(email string, time time.Time) {
	// 向管理员发送一条消息，说明用户已创建
	fmt.Println("Notify Deleted Admin Email:", email, time.Unix())
}

func (u UserDeletedNotifier) Handle(payload events.UserDeletedPayload) {
	// 发送消息
	u.NotifyAdmin(payload.Email, payload.Time)
}

func CreateUser() {
	// ...
	//声明通知对象
	createNotifier := notifier.UserCreatedNotifier{
		AdminEmail: "shirdon@example.com",
	}

	////注册通知对象
	events.UserCreated.Register(createNotifier)
	//触发事件
	events.UserCreated.Trigger(events.UserCreatedPayload{
		Email: "barry@example.com",
		Time:  time.Now(),
	})
	// ...
}

func DeleteUser() {
	// ...
	//声明通知对象
	deleteNotifier := notifier.UserDeletedNotifier{
		AdminEmail: "jack@example.com",
	}

	//注册通知对象
	events.UserDeleted.Register(deleteNotifier)
	//触发事件
	events.UserDeleted.Trigger(events.UserDeletedPayload{
		Email: "jack@example.com",
		Time:  time.Now(),
	})
	//触发事件
	events.UserDeleted.Trigger(events.UserDeletedPayload{
		Email: "steve@example.com",
		Time:  time.Now(),
	})
	// ...
}

func main() {
	//创建用户
	auth.CreateUser()
	//删除用户
	auth.DeleteUser()
}