// WithUnknownServiceHandler Inject an implementation of a method for handling unknown requests
// supporting only Thrift and Kitex protobuf protocols
func WithUnknownServiceHandler(f unknown.UnknownServiceHandler) Option {
    return Option{F: func(o *internal_server.Options, di *utils.Slice) {
       di.Push(fmt.Sprintf("WithUnknownServiceHandler(%+v)", utils.GetFuncName(f)))
       o.RemoteOpt.UnknownServiceHandler = f
       remote.PutPayloadCode(serviceinfo.Thrift, unknownservice.NewUnknownServiceCodec(thrift.NewThriftCodec()))
       remote.PutPayloadCode(serviceinfo.Protobuf, 
       unknownservice.NewUnknownServiceCodec(protobuf.NewProtobufCodec()))
    }}
}

func (s *server) registerUnknownServiceHandler() {
    if s.opt.RemoteOpt.UnknownServiceHandler != nil {
       if len(s.svcs.svcMap) == 1 && s.svcs.svcMap[serviceinfo.GenericService] != nil {
          panic(errors.New("generic services do not support handling of unknown methods"))
       } else {
          serviceInfo := unknownservice.NewServiceInfo(serviceinfo.Thrift, unknownservice.UnknownService, unknownservice.UnknownMethod)
          if err := s.RegisterService(serviceInfo, s.opt.RemoteOpt.UnknownServiceHandler); err != nil {
             panic(err)
          }
       }
    }
}

type unknownCodec struct {
    Codec remote.PayloadCodec
}
func (c unknownCodec) Marshal(ctx context.Context, msg remote.Message, out remote.ByteBuffer) error {}

func (c unknownCodec) Unmarshal(ctx context.Context, message remote.Message, in remote.ByteBuffer) error {}

func (c unknownCodec) Name() string { return "unknownServiceCodec"}

func (c unknownCodec) Unmarshal(ctx context.Context, message remote.Message, in remote.ByteBuffer) error {
    magicAndMsgType, err := codec.PeekUint32(in)
    if err != nil {
        return err
    }
    msgType := magicAndMsgType & codec.FrontMask
    if msgType == uint32(remote.Exception) {
        return c.Codec.Unmarshal(ctx, message, in)
    }
    if err = codec.UpdateMsgType(msgType, message); err != nil {
        return err
    }
    service, method, err := readDecode(message, in)
    if err != nil {
        return err
    }
    err = codec.SetOrCheckMethodName(method, message)
    ...
}

func readDecode(message remote.Message, in remote.ByteBuffer) (string, string, error) {
    code := message.ProtocolInfo().CodecType
    if code == serviceinfo.Thrift || code == serviceinfo.Protobuf {
       method, size, err := peekMethod(in)
       ....
       return message.RPCInfo().Invocation().ServiceName(), method, nil
    }
    return "", "", nil
}

func peekMethod(in remote.ByteBuffer) (string, int32, error) {
    buf, err := in.Peek(8)
    if err != nil {
       return "", 0, err
    }
    buf = buf[4:]
    size := int32(binary.BigEndian.Uint32(buf))
    buf, err = in.Peek(int(size + 8))
    if err != nil {
       return "", 0, perrors.NewProtocolError(err)
    }
    buf = buf[8:]
    method := string(buf)
    return method, size + 8, nil
}

err = codec.SetOrCheckMethodName(method, message)
var te *remote.TransError
if errors.As(err, &te) && (te.TypeID() == remote.UnknownMethod || te.TypeID() == remote.UnknownService) {
    svcInfo, err := message.SpecifyServiceInfo(service2.UnknownService, service2.UnknownMethod)
    if err != nil {
       return err
    }
    ...
 }
 return c.Codec.Unmarshal(ctx, message, in)

if ink, ok := ink.(rpcinfo.InvocationSetter); ok {
    ink.SetMethodName(service2.UnknownMethod)
    ink.SetPackageName(svcInfo.GetPackageName())
    ink.SetServiceName(service2.UnknownService)
} else {
    return errors.New("the interface Invocation doesn't implement InvocationSetter")
}

func callHandler(ctx context.Context, handler, arg, result interface{}) error {
    realArg := arg.(*Args)
    realResult := result.(*Result)
    realResult.Method = realArg.Method
    realResult.ServiceName = realArg.ServiceName
    success, err := handler.(UnknownServiceHandler).UnknownServiceHandler(ctx, realArg.ServiceName, realArg.Method, realArg.Request)
    if err != nil {
       return err
    }
    realResult.Success = success
    return nil
}

func (c unknownCodec) Marshal(ctx context.Context, msg remote.Message, out remote.ByteBuffer) error {
    ink := msg.RPCInfo().Invocation()
    data := msg.Data()

    res, ok := data.(*service2.Result)
    if !ok {
       return c.Codec.Marshal(ctx, msg, out)
    }
 }

if ink, ok := ink.(rpcinfo.InvocationSetter); ok {
    ink.SetMethodName(res.Method)
    ink.SetServiceName(res.ServiceName)
} else {
    return errors.New("the interface Invocation doesn't implement InvocationSetter")
}

func encode(res *service2.Result, msg remote.Message, out remote.ByteBuffer) error {
    if msg.ProtocolInfo().CodecType == serviceinfo.Thrift {
       return encodeThrift(res, msg, out)
    }
    if msg.ProtocolInfo().CodecType == serviceinfo.Protobuf {
       return encodeKitexProtobuf(res, msg, out)
    }
    return nil
}

// 实现UnknownServiceHandler接口,用来处理未知的请求
func (g *UnknownServiceImpl) UnknownServiceHandler(ctx context.Context, serviceName, method string, request []byte) (response []byte, err error) {
    m := request.([]byte)
    fmt.Printf("Recv: %v\n", m)
    req := "{\"Msg\": \"world\"}"
    return byte(req), nil
}

func NewServer(){
    var opts []server.Option
    // 把UnknownServiceHandler 添加到service中进行处理
    opts = append(opts, server.UnknownServiceHandler(new(UnknownServiceImpl)))
    svr := echo.NewServer(new(EchoImpl), opts...)
    if err := svr.Run(); err != nil {
        log.Fatal(err)
    }
}