package chat.handler;

import java.util.Set;

import chat.consts.MediaServerConfig;
import chat.consts.ProtoConstants;
import chat.module.Bucket;
import chat.module.entity.ChatSpaceType;
import chat.module.entity.MessageRecord;
import chat.security.DES;
import chat.server.call.CallObject;
import chat.server.call.ResultCode;
import chat.server.im.ResultPool;
import chat.server.moquette.message.MqttFixedHeader;
import chat.server.moquette.message.MqttMessageType;
import chat.server.moquette.message.MqttPublishMessage;
import chat.server.moquette.message.MqttPublishVariableHeader;
import chat.server.moquette.message.MqttQoS;
import chat.upload.UploadFile;
import cn.hutool.core.lang.UUID;
import cn.wildfirechat.proto.WFCMessage;
import io.moquette.spi.impl.security.AES;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.FullHttpRequest;

public class SystemHandler extends CallObject {
	
	private static final String KEY = "imfile";
	
	@Override
	protected void publishMethod() {
		addOneMethod("route");
		addOneMethod("getMediaUploadToken");
		addOneMethod("getQiniuUploadToken");
		addOneMethod("uploadFileToServer");
		addOneMethod("getSetting");
		addOneMethod("setSetting");
		addOneMethod("getToken");
		addOneMethod("modifyMyInfo");
		addOneMethod("multiCastMessage");
		addOneMethod("recallMessage");
		addOneMethod("sendMessage");
		addOneMethod("uploadDeviceToken");
	}

	public void route() throws Exception {
        WFCMessage.RouteResponse response = WFCMessage.RouteResponse.newBuilder().setHost("192.168.31.117").setLongPort(1883).setShortPort(80).build();
        byte[] resBytes = response.toByteArray();
		resultPool.setBytes(resBytes);
	}
	
	public void uploadDeviceToken() throws Exception {
		//头
		WFCMessage.UploadDeviceTokenRequest request = (WFCMessage.UploadDeviceTokenRequest) dataPool.getWFCMessage(WFCMessage.UploadDeviceTokenRequest.class);
		
		//尾
		resultPool.setBytes(null);
	}
	
	//IMTopic.SendMessageTopic  MS
	public void sendMessage() throws Exception {
		//头
		WFCMessage.Message message = (WFCMessage.Message) dataPool.getWFCMessage(WFCMessage.Message.class);
		
		long messageId = MessageRecord.newMessageId();
		long timeStamp = System.currentTimeMillis();
		message = message.toBuilder().setFromUser(user.getId()).setMessageId(messageId).setServerTimestamp(timeStamp).build();
		
		ChatSpaceType spaceType = ChatSpaceType.pase(message.getConversation().getType());
		Bucket<?> bucket = Bucket.getInstance(spaceType);
		bucket.pushOneMessage(message, user);
       
		//尾
        ByteBuf ackPayload = Unpooled.buffer();

        ackPayload = ackPayload.capacity(20);
        ackPayload.writeLong(messageId);
        ackPayload.writeLong(timeStamp);
        
	    byte[] resBytes = new byte[ackPayload.readableBytes()];
	    ackPayload.getBytes(0, resBytes);
	    
	    resultPool.setBytes(resBytes);
	}
	
	public int getNotifyReceivers(String userId, WFCMessage.Message.Builder messageBuilder, Set<String> notifyReceivers) throws Exception {
		int pullType = ProtoConstants.PullType.Pull_Normal;
		notifyReceivers.add(userId);
		notifyReceivers.add(messageBuilder.getConversation().getTarget());
		return pullType;
	}	
	
	public void recallMessage() throws Exception {
		//头
		WFCMessage.INT64Buf request = (WFCMessage.INT64Buf) dataPool.getWFCMessage(WFCMessage.INT64Buf.class);
		
		WFCMessage.INT64Buf.Builder requestB = request.toBuilder();
		requestB.setId(Long.parseLong(dataPool.getString("messageUid")));
		requestB.build();
		//尾
		
		resultPool.setBytes(null);
	}
	
	public void multiCastMessage() throws Exception {
		//头
		WFCMessage.MultiCastMessage multiCastMessage = (WFCMessage.MultiCastMessage) dataPool.getWFCMessage(WFCMessage.MultiCastMessage.class);
		
		//尾
		ByteBuf payload = Unpooled.buffer();
		long messageId = MessageRecord.newMessageId();
	    payload.ensureWritable(20).writeLong(messageId).writeLong(System.currentTimeMillis());
	    
	    byte[] resBytes = payload.array();
	    resultPool.setBytes(resBytes);
	}
	
	public void modifyMyInfo() throws Exception {
		//头
		WFCMessage.ModifyMyInfoRequest request = (WFCMessage.ModifyMyInfoRequest) dataPool.getWFCMessage(WFCMessage.ModifyMyInfoRequest.class);
		
		//尾
		resultPool.setBytes(null);
	}
	
	public void getToken() throws Exception {
		//头
		WFCMessage.GetTokenRequest request = (WFCMessage.GetTokenRequest) dataPool.getWFCMessage(WFCMessage.GetTokenRequest.class);
		
		WFCMessage.GetTokenRequest.Builder requestBuild = request.toBuilder();
		requestBuild.setUserId(dataPool.getString("userId"));
		requestBuild.setClientId(dataPool.getString("clientId"));
		requestBuild.setPlatform(dataPool.getInteger("platform", 0));
		
		request = requestBuild.build();
		
		//尾
		String strToken = "";
        String result = strToken + "|" + session.getSecret() + "|" + "123456";
        byte[] bytes = result.getBytes();
        
        resultPool.setBytes(bytes);
	}
	
	public void getQiniuUploadToken() throws Exception {
		String token;
		WFCMessage.GetUploadTokenResult.Builder resultBuilder = WFCMessage.GetUploadTokenResult.newBuilder();
		
        token = getToken(5);
        String domain = "http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT;
        resultBuilder.setDomain(domain);
        resultBuilder.setServer(MediaServerConfig.SERVER_IP);
        resultBuilder.setPort(MediaServerConfig.HTTP_SERVER_PORT);
        resultBuilder.setToken(token);

        byte[] data = resultBuilder.buildPartial().toByteArray();
		resultPool.setBytes(data);		
	}
	
	public void getMediaUploadToken() throws Exception {
		String token;
		int type;
		
		WFCMessage.GetUploadTokenRequest request = (WFCMessage.GetUploadTokenRequest) dataPool.getWFCMessage(WFCMessage.GetUploadTokenRequest.class);
		type = request.getMediaType();
		
		WFCMessage.GetUploadTokenResult.Builder resultBuilder = WFCMessage.GetUploadTokenResult.newBuilder();
		
        token = getToken(type);
        String domain = "http://" + MediaServerConfig.SERVER_IP + ":" + MediaServerConfig.HTTP_SERVER_PORT;
        resultBuilder.setDomain(domain);
        resultBuilder.setServer(MediaServerConfig.SERVER_IP);
        resultBuilder.setPort(MediaServerConfig.HTTP_SERVER_PORT);
        resultBuilder.setToken(token);

        byte[] data = resultBuilder.buildPartial().toByteArray();
		resultPool.setBytes(data);
	}
	
	public void uploadFileToServer() throws Exception {
		FullHttpRequest request = dataPool.getHttpRequest();
		String requestId = UUID.randomUUID().toString().replace("-", "");
		
		String key = UploadFile.multipartUpload(request, requestId);
		 
		resultPool.setNeedReturnCode(false);
		resultPool.add("key", key, false);
	}
	
    public static String getToken(int type) {
        String signKey = KEY + "|" + (System.currentTimeMillis()) + "|" + type;
        try {
            return DES.encryptDES(signKey);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
	
	public void getSetting() throws Exception {
		
	}
	
	public void setSetting() throws Exception {
		
	}
	
    public static MqttPublishMessage notRetainedPublish(String topic, MqttQoS qos, ByteBuf message) {
        return notRetainedPublishWithMessageId(topic, qos, message, 0);
    }

    private static MqttPublishMessage notRetainedPublishWithMessageId(String topic, MqttQoS qos, ByteBuf message,
            int messageId) {
        MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.PUBLISH, false, qos, false, 0);
        MqttPublishVariableHeader varHeader = new MqttPublishVariableHeader(topic, messageId);
        return new MqttPublishMessage(fixedHeader, varHeader, message);
    }
	
	public static void main(String[] args) {
        WFCMessage.RouteResponse response = WFCMessage.RouteResponse.newBuilder().setHost("192.168.31.117").setLongPort(1883).setShortPort(80).build();
        byte[] resBytes = response.toByteArray();
        resBytes = AES.AESEncrypt(resBytes, "31a95a1a-d169-4a26-be4c-ef73088c1b1f");

//		data = Base64.getEncoder().encode(data);
		
        ByteBuf buf = Unpooled.buffer();
        
        buf.ensureWritable(1).writeByte(ResultCode.Success.getValue());
        buf.ensureWritable(resBytes.length).writeBytes(resBytes);
        
        System.out.println(buf);
	
	}
}