package com.hisen.ws.server;

import com.hisen.ws.util.Constants;

import Javax.websocket.*;
import Javax.websocket.server.ServerEndpoint;
import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.List;
import Java.util.Map;
import Java.util.Optional;
import Java.util.concurrent.ConcurrentHashMap;

/**
 * @ServerEndpoint 注解是一个类层次的注解，它的功能主要是将目前的类定义成一个websocket服务器端,
 * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
 */
@ServerEndpoint("/websocket")
public class WebSocketServer {
    // 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;

    // 实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
    private static ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    // 当前用户
    private String user;

    /**
     * 客户端可以是web页面，也可以是Java后台
     * <p>
     * 通过连接或者message可以控制发送给谁
     *
     * @param message 客户端发送过来的消息
     * @param session 可选的参数
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("来自客户端的消息:" + message);
        // 获取url传过来的参数
        Map<String, List<String>> parameterMap = session.getRequestParameterMap();
        // 发送方式
        String method = null;
        // 发送给哪些人
        List<String> receivers = new ArrayList<>();
        // 发送者
        String sernder = null;
        if (parameterMap.containsKey(Constants.METHOD)) {
            method = parameterMap.get(Constants.METHOD).get(0);
        }
        if (parameterMap.containsKey(Constants.SEND_TO)) {
            receivers = parameterMap.get(Constants.SEND_TO);
        }
        if (parameterMap.containsKey(Constants.USER)) {
            sernder = parameterMap.get(Constants.USER).get(0);
        }

        System.out.println("sender:" + sernder + ",receivers:" + receivers.toString() + ",method:" + method);
        if (method == null || method.equals(Constants.METHOD_ALL)) {
            //发送所有
            send2All(message);
        } else {
            //单发
            send2Users(receivers, message);
        }

    }

    /**
     * 连接建立成功调用的方法
     *
     * @param session 可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        this.user = session.getRequestParameterMap().get(Constants.USER).get(0);
        // 放入map
        webSocketMap.put(user, this);
        //在线数加1
        addOnlineCount();
        System.out.println("有新连接加入！当前在线人数为" + getOnlineCount() + ",session:" + session.getId() + ",user:" + this.user);
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        // 移除
        webSocketMap.remove(this.user);
        //在线数减1
        subOnlineCount();
        System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount() + ",user:" + this.user);
    }


    private void send2Users(List<String> receivers, String message) {
        receivers.forEach(e -> {
            System.out.println("single receiver:" + e);
            Optional.ofNullable(webSocketMap.get(e))
                    .filter(webSocketServer -> webSocketServer.session.isOpen())
                    .ifPresent(webSocketServer -> sendOnce(message, e, webSocketServer));
        });
    }

    private void send2All(String message) {
        webSocketMap.forEach((key, value) -> {
            sendOnce(message, key, value);
        });
    }

    private void sendOnce(String message, String e, WebSocketServer webSocketServer) {
        try {
            webSocketServer.sendMessage(message);
        } catch (IOException exp) {
            System.out.println("发送出错，receiver:" + e);
        }
    }

    /**
     * 发生错误时调用
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误，user:" + this.user);
        error.printStackTrace();
    }

    /**
     * 自定义的方法
     *
     * @param message
     * @throws IOException
     */
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
        //this.session.getAsyncRemote().sendText(message);
    }

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

/**
 *
 * @param person 目前所有的人
 * @param lucklys 这一轮已经值班了的人
 */

private static void findLucklyOneByHashCode(List<String> person, ArrayList<String> lucklys) {
    List<String> result = new ArrayList<>(person);
    result.removeAll(lucklys);
    if (result.size() == 0) {
        lucklys.clear();
        result = new ArrayList<>(person);
    }
    String code = System.nanoTime() + UUID.randomUUID().toString();
    int index = Math.abs(code.hashCode()) % result.size();
    String lucklyOne = result.get(index);
    System.out.println("lucklyOne:" + lucklyOne);
    lucklys.add(lucklyOne);
}
/**
 * hashCode随机取出来的数据
 * lucklyOne:G
 * lucklyOne:B
 * lucklyOne:C
 * lucklyOne:D
 * lucklyOne:H
 * lucklyOne:F
 * lucklyOne:E
 * lucklyOne:A
 */

@Test
public void testCopy() {
    String oldFileName = "/Users/hisenyuan/hisen/blog/source/_posts/Test-Java-Code.md";
    String newFileName = "/Users/hisenyuan/hisen/test/Test-Java-Code.md";
    nioCopy(oldFileName, newFileName);
    ioCopy(oldFileName, newFileName.replace(".md", ".md.bak"));
    ioCopyByLine(oldFileName,newFileName.replace(".md",".bak." + System.currentTimeMillis()));
}

/**
 * 利用NIO进行读写文件
 *
 * @param oldFileName 原文件的路径
 * @param newFileName 新文件的路径
 */
public static void nioCopy(String oldFileName, String newFileName) {
    try {
        FileChannel fileChannelIn = new FileInputStream(new File(oldFileName)).getChannel();
        FileChannel fileChannelOut = new FileOutputStream(new File(newFileName)).getChannel();
        //获取文件大小
        long size = fileChannelIn.size();
        System.out.printf("文件大小为：%s byte \n", size);
        //缓冲
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        long start = System.currentTimeMillis();
        while (fileChannelIn.read(byteBuffer) != -1) {
            //准备写
            byteBuffer.flip();
            fileChannelOut.write(byteBuffer);
            //准备读
            byteBuffer.clear();
        }
        long end = System.currentTimeMillis();
        System.out.printf("NIO方式复制完成，耗时 %s 秒\n", (end - start) / 1000);
        //关闭
        fileChannelIn.close();
        fileChannelOut.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
 * IO方式复制文件
 *
 * @param oldFileName
 * @param newFileName
 */
public static void ioCopy(String oldFileName, String newFileName) {
    try {
        FileInputStream fileInputStream = new FileInputStream(new File(oldFileName));
        FileOutputStream fileOutputStream = new FileOutputStream(new File(newFileName));

        long length = new File(oldFileName).length();

        System.out.printf("文件大小为：%s byte \n", length);
        byte[] buffer = new byte[1024];

        long start = System.currentTimeMillis();
        int len = 0;
        //EOF = End Of File，其默认值就是-1
        while ((len = fileInputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }
        long end = System.currentTimeMillis();
        System.out.printf("IO方式复制完成，耗时 %s 秒\n", (end - start) / 1000);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void ioCopyByLine(String oldFileName, String newFileName) {
    try {
        BufferedReader reader = new BufferedReader(new FileReader(oldFileName));
        BufferedWriter writer = new BufferedWriter(new FileWriter(newFileName));
        String line;
        while ((line = reader.readLine()) != null) {
            writer.write(line);
            writer.newLine();
            writer.flush();
        }
    } catch (IOException e) {
        System.out.println("error:" + e);
    }
}

public void testCreate() {
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("hisenyuan").build();
        ExecutorService pool = new ThreadPoolExecutor(
                20,
                50,
                10000L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(10240),
                namedThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 50; i++) {
            // 需要提交的内容
            pool.execute(this::createTokenTest);
        }
        pool.shutdown();
        try {
            while (!pool.awaitTermination(500, TimeUnit.MILLISECONDS)) {
                LOGGER.debug("Waiting for terminate");
            }
        } catch (InterruptedException e) {
            LOGGER.error(e);
        }
    }

@RequestMapping(value = "/test", method = RequestMethod.POST)
public String webCharge(HttpServletRequest request, HttpServletResponse response) {
    if (1==1) {
        response.setStatus(200);
        return "redirect:https://github.com/hisenyuan";
    } else {
        try {
            response.setStatus(405);
            response.getWriter().write(JSON.toJSONString("hisenyuan"));
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}