package frame.file;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import frame.data.Entity;
import frame.data.EntitySet;
import frame.file.office.IOHandler;
import frame.file.office.IOMapping;
import frame.file.office.IOMappingItem;
import frame.persist.NamedSQL;
import frame.persist.SQLRunner;

public class FileIOContainer {

    private static FileIOContainer instance;
    private static Object locker = new Object();

    private Map<String, FileIO> fileIOMap;
    private Map<String, FileIOItem> ioItemMap;
    private Map<String, IOMapping> ioMappingMap;
    private List<FileIO> fileIOList;
    
	 private FileIOContainer() {
         fileIOMap = new HashMap<String, FileIO>();
         ioItemMap = new HashMap<String, FileIOItem>();
         ioMappingMap = new HashMap<String, IOMapping>();
         fileIOList = new ArrayList<FileIO>();
     }

     public static FileIOContainer getInstance() {
         if (instance == null) {
             synchronized (locker) {
            	 if (instance == null) {
                     instance = new FileIOContainer();
                 }
			} 
         }

         return instance;
     }
     
     public static FileIO get(String ioCode) {
         getInstance();

         if (ioCode == null) {
             return null;
         }

         ioCode = ioCode.toLowerCase();

         if (!instance.fileIOMap.containsKey(ioCode)) {
             return null;
         }

         return instance.fileIOMap.get(ioCode);
     }
     
     public static void load() throws Exception {
         getInstance(); 
         NamedSQL namedSQL;
         Entity entity;
         instance.clear();

         //1. load mapping
         namedSQL = NamedSQL.getInstance("getMappingList");
         EntitySet mappingList = SQLRunner.getEntitySet(namedSQL);

         while (mappingList.hasNext()) {
             entity = mappingList.next();

             IOMapping mapping = new IOMapping();
             mapping.initLoad(entity);

             instance.ioMappingMap.put(mapping.getId(), mapping);
         }

         //2. load mapping detail
         namedSQL = NamedSQL.getInstance("getMappingDetails");
         EntitySet mappingDetails = SQLRunner.getEntitySet(namedSQL);

         while (mappingDetails.hasNext()) {
             entity = mappingDetails.next();

             IOMappingItem mappingItem = new IOMappingItem();
             mappingItem.initLoad(entity);

             IOMapping mapping = instance.getIOMapping(mappingItem.getParentId());

             if (mapping == null) {
                 return;
             }

             mapping.addItem(mappingItem);
         }
       
         //3. load fileio
         namedSQL = NamedSQL.getInstance("getFileIOList");
         EntitySet fileIOList = SQLRunner.getEntitySet(namedSQL);

         while (fileIOList.hasNext()) {
             entity = fileIOList.next();
             
             FileIO fileIO = new FileIO();
             fileIO.load(entity);

             instance.addFileIO(fileIO);
         }           

         //4. load fileio item
         namedSQL = NamedSQL.getInstance("getFileIOItemList");
         EntitySet fileIOItemList = SQLRunner.getEntitySet(namedSQL);

         while (fileIOItemList.hasNext()) {
             entity = fileIOItemList.next();

             String ioCode = entity.getString("code");
             FileIO fileIO = instance.getFileIO(ioCode);

             if (fileIO == null) {
                 return;
             }

             FileIOItem ioItem = new FileIOItem();
             ioItem.initLoad(entity);

             IOMapping mapping = instance.ioMappingMap.get(ioItem.getMappingId());
             ioItem.setMapping(mapping);

             fileIO.addItem(ioItem);
             instance.ioItemMap.put(ioItem.getId(), ioItem);
         }

         //5. create mapping runtime
         for (FileIO fileIO : instance.fileIOList) {
             fileIO.createRuntime();
         }

         //6. load ioItem handler
         namedSQL = NamedSQL.getInstance("getIOItemHandlerList");
         EntitySet privateHandlers = SQLRunner.getEntitySet(namedSQL);

         while (privateHandlers.hasNext()) {
             entity = privateHandlers.next();

             IOHandler handler = new IOHandler();
             handler.initLoad(entity);

             FileIOItem ioItem = instance.getIOItem(handler.getItemId());

             if (ioItem == null) {
                 return;
             }

             ioItem.addHandler(handler);
         }

         //7. load fileIO handler
         namedSQL = NamedSQL.getInstance("getFileIOHandlerList");
         EntitySet publicHandlerList = SQLRunner.getEntitySet(namedSQL);

         while (publicHandlerList.hasNext()) {
             entity = publicHandlerList.next();

             IOHandler handler = new IOHandler();
             handler.initLoad(entity);

             FileIO fileIO = instance.getFileIO(handler.getFileIoCode());

             if (fileIO == null) {
                 return;
             }

             fileIO.addHandler(handler);
         }
     }

     private void clear() {
         fileIOList.clear();

         fileIOMap.clear();
         ioItemMap.clear();
         ioMappingMap.clear();
     }

     private FileIO getFileIO(String code) {
         if (code == null) {
             return null;
         }

         code = code.toLowerCase();

         if (!instance.fileIOMap.containsKey(code)) {
             return null;
         }

         return instance.fileIOMap.get(code);
     }

     private FileIOItem getIOItem(String id) {
         if (!instance.ioItemMap.containsKey(id)) {
             return null;
         }

         return instance.ioItemMap.get(id);
     }

     private IOMapping getIOMapping(String id) {
         if (!instance.ioMappingMap.containsKey(id)) {
             return null;
         }

         return instance.ioMappingMap.get(id);
     }

     private void addFileIO(FileIO fileIO) {
         String ioCode = fileIO.getCode();

         if (ioCode == null) {
             return;
         }

         ioCode = ioCode.toLowerCase();
         instance.fileIOMap.put(ioCode, fileIO);

         fileIOList.add(fileIO);
     }
}