package com.carey.tel;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
 
public class JavaTelArea {
     private static JavaTelArea jta = null;
     private static final String INDEXDATAFILE = "tel.bin";
     private static Hearder cacheHearder = null;
     private static AreaCode cacheAreaCode = null;
     private static String cacheIndexFilePath = null;
 
     public static void main(String[] args) {
          JavaTelArea ctc = JavaTelArea.getInstance();
          //ctc.genIndexFile("e:\", "e:\telphone.txt");
          String indexPath = "e:\";
 
          long startTime = new Date().getTime();
          String searchNum = "13889650920";
          String res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
 
          startTime = new Date().getTime();
          searchNum = "+8613659867583";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
 
          startTime = new Date().getTime();
          searchNum = "1301815";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
 
          startTime = new Date().getTime();
          searchNum = "1301816";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println("没有预测");
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
 
          startTime = new Date().getTime();
          searchNum = "1301816";
      res = ctc.searchTel(indexPath, searchNum, true);
      System.out.println("根据号码连贯性原理预测");
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
 
          startTime = new Date().getTime();
          searchNum = "1301817";
          res = ctc.searchTel(indexPath, searchNum);
          System.out.println(searchNum + " : " + res);
          System.out.println(System.currentTimeMillis() - startTime + "ms");
    }
 
    private HashMap<Long, String> generateTestData() {
          HashMap<Long, String>
          telToAreaCode = new HashMap<Long, String>();
          telToAreaCode.put(1310944l, "新疆伊犁州");
          telToAreaCode.put(1301263l, "新疆伊犁州");
          telToAreaCode.put(1301264l, "新疆伊犁州");
          telToAreaCode.put(1301260l, "新疆伊犁州");
          telToAreaCode.put(955L, "海南");
          telToAreaCode.put(1320955l, "海南");
          telToAreaCode.put(1320957l, "海南");
          telToAreaCode.put(1300561L, "陕西商州");
          telToAreaCode.put(1300562L, "陕西商州");
          return telToAreaCode;
    }
 
    public static synchronized JavaTelArea getInstance() {
         if (jta == null) {
               jta = new JavaTelArea();
         }
         return jta;
    }
 
   /**   * Generate Index File (tel.bin)     * */
   private void genIndexFile(String indexFilePath, String souceFile) {
         ArrayList<String> strs = readFileToList(souceFile);
         HashMap<Long, String>
         telToArea = createTel2AreaHashMap(strs);
         writeDate(indexFilePath + INDEXDATAFILE, telToArea);
   }
 
   /**   * read file content to String array list, every line one string.    * */
   private ArrayList<String> readFileToList(String filePath) {
        final ArrayList<String>
        strLists = new ArrayList<String>();
 
        BufferedReader bReader = null;
        try {
              bReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
              String str = bReader.readLine();
              while (str != null) {
                   strLists.add(str);
                   str = bReader.readLine();
              }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
           if (bReader != null) {
               try {
                     bReader.close();
               } catch (IOException e) {
                    e.printStackTrace();
               }
          }
       }
       return strLists;
    }
 
     /**     * create telephone number to area hash map.     * */
     HashMap<Long, String> createTel2AreaHashMap(ArrayList<String> strs) {
           final HashMap<Long, String>
           telToArea = new HashMap<Long, String>();
 
           String[] tels = null;
           int len = 0;
           String strArea = null;
           for (String string : strs) {
               tels = string.split(" ");
               len = tels.length;
               strArea = tels[len - 1].substring(1);
 
               for (int i = 0; i < len - 1; i++) {
                    telToArea.put(Long.valueOf(tels[i]), strArea);
               }
           }
         return telToArea;
    }
 
    /**  * combined the adjacent Records.    * */
    private void combinedRecords(ArrayList<Record> records, Record newRecord) {
          int size = records.size();
          if (size > 0&& records.get(size - 1).areacodeIndex == newRecord.areacodeIndex) {
               // combined
              Record lastRecord = records.get(size - 1);
              lastRecord.numCnt = (int) (newRecord.baseTelNum - lastRecord.baseTelNum) + newRecord.numCnt;
         } else {
              records.add(newRecord);
         }
    }
 
   /**   * write index info to file.     * */
   private void writeDate(String filePath, HashMap<Long, String> telToAreaCode) {
       // 1. get all area info
       ArrayList<String> tmpAreaCodes = new ArrayList<String>(telToAreaCode.values());
       ArrayList<String> strAreaCodes = new ArrayList<String>();
       for (String str : tmpAreaCodes) {
            if (!strAreaCodes.contains(str)) {
                    strAreaCodes.add(str);
            }
       }
       tmpAreaCodes.clear();
       tmpAreaCodes = null;
 
       StringBuffer sb = new StringBuffer();
       for (String str : strAreaCodes) {
                 sb.append(str + ",");
       }
       sb.deleteCharAt(sb.length() - 1);
 
       AreaCode areaCode = new AreaCode(sb.toString());
       areaCode.print();
 
       // 2. Sort HashMap and combined the adjacent telephone number
       ArrayList<Long> telNunms = new ArrayList<Long>(telToAreaCode.keySet());
       Collections.sort(telNunms);
       ArrayList<Record> records = new ArrayList<Record>();
       long baseNum = 0;
       String baseArea = null;
       int numCnt = 0;
       for (Long tm : telNunms) {
             if (numCnt == 0) {
                    baseNum = tm;
                    baseArea = telToAreaCode.get(tm);
                    numCnt = 1;
             } else {
                    if (tm == baseNum + numCnt && baseArea.equals(telToAreaCode.get(tm))) {
              numCnt++;
                    } else {
                         combinedRecords(records, new Record(baseNum, numCnt,   strAreaCodes.indexOf(baseArea)));
                         baseNum = tm;
                         baseArea = telToAreaCode.get(tm);
                         numCnt = 1;
                    }
             }
          }
         combinedRecords(records,   new Record(baseNum, numCnt, strAreaCodes.indexOf(baseArea)));       
 
         // for (Record record : records) {
               // record.print();
         // }
 
         // 3. Write data to the file
         RandomAccessFile raf = null;
         try {
                raf = new RandomAccessFile(filePath, "rw");
                raf.seek(0);
 
                Hearder hearder = new Hearder();
                hearder.firstRecordOffset = hearder.Size() + areaCode.Size();
                hearder.lastRecordOffset = hearder.firstRecordOffset    + (records.size() - 1) * records.get(0).Size();
                hearder.print();
                hearder.write(raf);
 
                areaCode.write(raf);
 
                for (Record record : records) {
                       record.write(raf);
                }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              if (raf != null) {
                    try {
                           raf.close();
                     } catch (IOException e) {
                            e.printStackTrace();
                     }
              }
          }
    }
 
   class Hearder {
         int firstRecordOffset;
         int lastRecordOffset;
 
         public int Size() {
                 return (Integer.SIZE + Integer.SIZE) / Byte.SIZE;
         }
 
         public void write(RandomAccessFile raf) throws IOException {
                raf.writeInt(this.firstRecordOffset);
                raf.writeInt(this.lastRecordOffset);
         }
 
        public void read(RandomAccessFile raf) throws IOException {
               this.firstRecordOffset = raf.readInt();
               this.lastRecordOffset = raf.readInt();
        }
 
        public void print() {
                System.out.println("===== Hearder ===== ");
                System.out.println("[" + firstRecordOffset + " , "   + lastRecordOffset + "]");
        }
    }
 
   class AreaCode {
          private String areacode;
          private String[] codes;
 
          public AreaCode() {
               this("");
          }
 
          public AreaCode(String areacode) {
               this.areacode = areacode;
               this.codes = null;
          }
 
          public int Size() {
                 return areacode.getBytes().length + (Integer.SIZE / Byte.SIZE);
          }
 
          public void print() {
                System.out.println("===== AreaCode ===== ");
                System.out.println("[" + areacode.getBytes().length + "]" + areacode);
          }
 
         public void write(RandomAccessFile raf) throws IOException {
        raf.writeInt(areacode.getBytes().length);
                raf.write(this.areacode.getBytes());
         }
 
         public void read(RandomAccessFile raf) throws IOException {
                byte[] bytes = new byte[raf.readInt()];
                raf.read(bytes);
                this.areacode = new String(bytes);
         }
 
         public String getCodeByIndex(int index) {
             if (this.codes == null) {
                   this.codes = this.areacode.split(",");
             }
             return (index < 0 || this.codes == null || index >= this.codes.length) ? null   : this.codes[index];
        }
}
 
class Record {
       long baseTelNum;
       int numCnt;
       int areacodeIndex;
 
       public Record() {
            this(0, 0, 0);
       }
 
       public Record(long baseTelNum, int numCnt, int areacodeIndex) {
             this.baseTelNum = baseTelNum;
             this.numCnt = numCnt;
             this.areacodeIndex = areacodeIndex;
       }
 
       public void print() {
             System.out.println("===== Record ===== ");
             System.out.println("<" + baseTelNum + "> <" + numCnt + "> <" + areacodeIndex + ">");
       }
 
      public int Size() {
             return (Long.SIZE + Integer.SIZE) / Byte.SIZE;
      }
 
      public void write(RandomAccessFile raf) throws IOException {
           raf.writeLong(this.baseTelNum);
           int tmp = this.numCnt << 16;
           tmp += 0xFFFF & this.areacodeIndex;
           raf.writeInt(tmp);
      }
 
     public void read(RandomAccessFile raf) throws IOException {
          this.baseTelNum = raf.readLong();
          int tmp = raf.readInt();
          this.numCnt = tmp >> 16;
          this.areacodeIndex = 0xFFFF & tmp;
     }
 
     public int inWhich(long telNum) {
         if (telNum < this.baseTelNum) {
               return -1;
         } else if (telNum >= this.baseTelNum + this.numCnt) {
               return 1;
         } else {
               return 0;
         }
    }
 }
 
  public String searchTel(String indexFilePath, String telNum) {
          return searchTel(indexFilePath, telNum, false);
  }
 
  /**    * search    * */
  public String searchTel(String indexFilePath, String telNum, boolean forecast) {
    StringBuffer sb = new StringBuffer(telNum);
 
    // +
    if (sb.charAt(0) == '+') {
        sb.deleteCharAt(0);
    }
 
    // 86
    if (sb.charAt(0) == '8' && sb.charAt(1) == '6') {
        sb.delete(0, 2);
    }
 
    // 以0开头，是区号
    if (sb.charAt(0) == '0') {
        sb.deleteCharAt(0);
        // 首先按照4位区号查询，若查询为空，再按3位区号查询
        if (sb.length() >= 3) {
            sb.delete(3, sb.length());
        } 
 
        String dial = searchTel(indexFilePath, Long.valueOf(sb.toString()),false);
            
        if (dial != null) {
            return dial;
        }
            
        if (sb.length() >= 2) {
            sb.delete(2, sb.length());
        }
    }
    // 以1开头，是手机号或者服务行业号码
    else if (sb.charAt(0) == '1') {
        // 首先按照手机号码查询，若查询为空，再按特殊号码查询
            
        if (sb.length() > 7) {
            String dial = searchTel(indexFilePath, Long.valueOf(sb.substring(0, 8)),false);
                
            if (dial != null) {
                return dial;
            }
                
            dial = searchTel(indexFilePath, Long.valueOf(sb.toString()),false);
                
            if (dial != null) {
                return dial;
            }
                
            // 只需要保留7位号码就ok了，多余的删掉
            if (sb.length() > 7) {
                sb.delete(7, sb.length());
            }
        } else {
            //小于7位，最有可能是服务号码
            //do nothing.
        }
    }
    // 以其他数字开头，这也不知道是啥号码了
    else {
        //do nothing.
    }
 
    return searchTel(indexFilePath, Long.valueOf(sb.toString()), forecast);
  }
 
 private String searchTel(String indexFilePath, long telNum, boolean forecast) {
          RandomAccessFile raf = null;
          try {
             raf = new RandomAccessFile(indexFilePath + INDEXDATAFILE, "r");
             if (cacheIndexFilePath == null || !cacheIndexFilePath.equals(indexFilePath)) {
                cacheIndexFilePath = indexFilePath;
                cacheHearder = new Hearder();
                cacheHearder.read(raf);
                cacheHearder.print();
 
                cacheAreaCode = new AreaCode();
                cacheAreaCode.read(raf);
                cacheAreaCode.print();
             }
 
            int index = lookUP(raf, cacheHearder.firstRecordOffset, cacheHearder.lastRecordOffset, telNum, forecast);
            return cacheAreaCode.getCodeByIndex(index);
         } catch (Exception e) {
              e.printStackTrace();
         } finally {
              if (raf != null) {
                  try {
                         raf.close();
                  } catch (IOException e) {
                       e.printStackTrace();
                  }
               }
         }
 
      return null;
  }
 
  private int lookUP(RandomAccessFile raf, long startpos, long endpos, long looknum, boolean forecast) throws IOException {
      Record record = new Record();
      long seekpos = 0;
 
      do {
            seekpos = startpos + (endpos - startpos) / record.Size() / 2 * record.Size();
            raf.seek(seekpos);
            record.read(raf);
 
           if (record.inWhich(looknum) > 0) {
                 startpos = seekpos + record.Size();
           } else if (record.inWhich(looknum) < 0) {
                 endpos = seekpos - record.Size();
           } else {
                 return record.areacodeIndex;
           }
      } while (startpos <= endpos);
 
     if (forecast) {
            return record.areacodeIndex;
     } else {
           return -1;
     }
  }
}