package com.back.communication;

import com.back.common.Common;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStream;

import com.back.action.Log;

public class SerialSMS implements SerialPortEventListener {

  public final static String PORT_OWER = "SMS";

  private boolean isOpen;

  private boolean isStart;

  private String portName;
  private String commSet;

  private CommPortIdentifier portId;

  private SerialPort serialPort;

  private DataInputStream inputStream;

  private OutputStream outputStream;

  private Object readWriteLock = new Object();

  private String serialdata = "";

  Boolean isread = false;

  private String clazzName = new Object() {
    public String getClassName() {
      String clazzName = this.getClass().getName();
      return clazzName.substring(0, clazzName.lastIndexOf('$'));
    }
  }.getClassName();

  public static SerialSMS Instance;

  public static SerialSMS getInstance(String port, String smsset) {
    if (Instance == null) {
      Instance = new SerialSMS(port, smsset);
    }

    return Instance;
  }

  private SerialSMS(String port, String smsset) {
    isOpen = false;
    isStart = false;

    portName = port;
    commSet = smsset;
  }

  public void init() throws IOException, Exception {
    if (isOpen) {
      close();
    }

    try {
      // 根据传入的串口名创建串口标识
      portId = CommPortIdentifier.getPortIdentifier(portName);
      // 打开串口并返回串口对象
      serialPort = (SerialPort) portId.open(PORT_OWER, 2000);

      // 通过串口对象获得输入流
      inputStream = new DataInputStream(serialPort.getInputStream());

      // 通过串口对象获得输出流
      outputStream = serialPort.getOutputStream();

      serialPort.getReceiveTimeout();

      isOpen = true;
    } catch (NoSuchPortException ex) {
      ex.printStackTrace();
      System.err.println(ex.getMessage());
    } catch (PortInUseException ex) {
      System.err.println(ex.getMessage());
    }
  }

  public void start() throws Exception {
    if (!isOpen) {
      Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName() + "->"
          + portName + " has not been opened.");
    }

    // 设置串口监听对象
    serialPort.addEventListener(this);

    // 设置串口数据可用
    serialPort.notifyOnDataAvailable(true);

    /* 设置串口初始化参数，依次是波特率，校验位,数据位，停止位 */
    String[] array = commSet.split(",");
    int baud = Integer.parseInt(array[0]);
    int databits = Integer.parseInt(array[2]);
    int stopbits = Integer.parseInt(array[3]);
    String parity = array[1].toLowerCase();
    int intparity = 0;
    if (parity.equals("n")) {
      intparity = 0;
    } else if (parity.equals("o")) {
      intparity = 1;
    } else if (parity.equals("e")) {
      intparity = 2;
    }
    serialPort.setSerialPortParams(baud, databits, stopbits, intparity);

    isStart = true;
  }

  public void stop() {
    if (isStart) {
      // 设置串口数据是否可用
      serialPort.notifyOnDataAvailable(false);

      // 移除串口监听事件
      serialPort.removeEventListener();

      isStart = false;
    }
  }

  public void close() {
    stop();

    if (isOpen) {
      try {
        // 关闭流对象与串口对象
        inputStream.close();
        outputStream.close();
        serialPort.close();
        serialPort = null;

        isOpen = false;
      } catch (IOException ex) {
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->Error:" + ex.getMessage());

      }
    }
  }

  public void serialEvent(SerialPortEvent event) {
    switch (event.getEventType()) {
    case SerialPortEvent.BI:
    case SerialPortEvent.OE:
    case SerialPortEvent.FE:
    case SerialPortEvent.PE:
    case SerialPortEvent.CD:
    case SerialPortEvent.CTS:
    case SerialPortEvent.DSR:
    case SerialPortEvent.RI:
    case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
      break;
    case SerialPortEvent.DATA_AVAILABLE:
      // 从串口获得数据，获取的数据以流的形式读取
      readComm();
      break;
    default:
      break;
    }
  }

  public boolean writeCommTxt(String phone, String Msg) {
    synchronized (readWriteLock) {
      boolean flag = false;

      try {
        String data = "AT+CMGF=1\r\n";// 文本发送
        serialdata = "";
        outputStream.write(data.getBytes());
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->write AT+CMGF=1 .......1");
        for (int i = 0; i < 5000; i++) // 2012-06-20
        {
          if (serialdata.contains("-4F-4B-")) { // OK
            break;
          }

          Thread.sleep(1);
        }
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->write AT+CMGF=1 .......2");
        if (serialdata.contains("-4F-4B-")) {
          serialdata = "";
          flag = true;
        } else {
          return false;
        }

        data = "AT+CSCS=\"GSM\"\r\n";
        serialdata = "";
        outputStream.write(data.getBytes());

        for (int i = 0; i < 500; i++) {
          if (serialdata.contains("-4F-4B-")) {
            break;
          }
          Thread.sleep(1);
        }
        serialdata = "";

        // data = center + code;
        serialdata = "";
        Msg = ">" + Msg;
        outputStream.write(Msg.getBytes());
        outputStream.write((char) 26);// ctrl+Z发送
        for (int i = 0; i < 10000; i++) // 2012-06-20
        {

          if (serialdata.contains("-4F-4B-")) {
            break;
          }

          Thread.sleep(1);
        }

      } catch (Exception e) {
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->ERROR:" + e.toString());
        e.printStackTrace();
      }
      if (serialdata.contains("-4F-4B-")) { // 发送成功
        flag = true;
      } else {
        flag = false;
      }
      return flag;
    }
  }

  /** 写指令到串口 */
  public boolean writeComm(String center, String code) {
    synchronized (readWriteLock) {
      boolean flag = false;

      try {
        String data = "AT+CMGF=0\r\n";// 文本发送 设置为PDU模式
        serialdata = "";
        outputStream.write(data.getBytes());
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->write AT+CMGF=0 .......1");
        for (int i = 0; i < 5000; i++) // 2012-06-20
        {
          if (serialdata.contains("-4F-4B-")) { // OK
            break;
          }

          Thread.sleep(1);
        }
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->write AT+CMGF=0 .......2");
        if (serialdata.contains("-4F-4B-")) {
          serialdata = "";
          flag = true;
        } else {
          return false;
        }

        if (flag) {
          int intLen = code.length() / 2;
          data = "AT+CMGS=" + intLen + "\r\n";
          serialdata = "";
          outputStream.write(data.getBytes());

          for (int i = 0; i < 500; i++) {
            if (serialdata.contains("-4F-4B-")) {
              break;
            }
            Thread.sleep(1);
          }
          serialdata = "";

          // data = center + code;
          data = code;
          serialdata = "";
          outputStream.write(data.getBytes());
          outputStream.write((char) 26);// ctrl+Z发送
          for (int i = 0; i < 10000; i++) // 2012-06-20
          {

            if (serialdata.contains("-4F-4B-")) {
              break;
            }

            Thread.sleep(1);
          }
        }
      } catch (Exception e) {
        Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
            + "->ERROR:" + e.toString());
        e.printStackTrace();
      }
      if (serialdata.contains("-4F-4B-")) { // 发送成功
        flag = true;
      } else {
        flag = false;
      }
      return flag;
    }
  }

  /** 用流读取数据，写事件表和写结果表 */
  public void readComm() {
    int num = 0;// buffer中的数据长度
    byte[] readbuffer = new byte[1024];
    try {
      if (inputStream.available() > 0) {
        num = inputStream.read(readbuffer);
      } else {
        return;
      }
      serialdata = serialdata + Common.GetHexStr(readbuffer, num);
    } catch (IOException e) {
      Log.writelog(clazzName, Thread.currentThread().getStackTrace()[1].getMethodName()
          + "->ERROR:" + e.toString());
      return;
    }
  }
}