using 
{ 
    Qt;   
};

class ArgsProcessor {
    String[] args;
    int cmd = 0;
    public String configure = nilptr;
    public String targetpath = nilptr;
    public String xcross = nilptr;
    public String arch = nilptr;
    public String project = nilptr;
    
    public static const int CMD_INSTXP = 1,
                     CMD_LOADXPRJ = 2,
                     CMD_BUILD = 3;

    public ArgsProcessor(@NotNilptr String []_arg) {
        args = _arg;

        if (args.length > 1) {
            if (args[1].equals("-installpkg")) {
                cmd = CMD_INSTXP;
            } else if (args[1].equals("-build")) {
                cmd = CMD_BUILD;
            } else {
                cmd = CMD_LOADXPRJ;
            }
        }
    }

    public int getCommand() {
        return cmd;
    }

    public bool parse() throws IllegalArgumentException {
        if (cmd == CMD_BUILD) {
            if (args[1].equals("-build")) {
                for (int i = 2; i < args.length; i++) {
                    if (args[i].startsWith("--config=")) {
                        configure = args[i].substring(9, args[i].length());
                    } else if (args[i].startsWith("--targetdir=")) {
                        targetpath = args[i].substring(12, args[i].length());
                    } else if (args[i].startsWith("--xcross=")) {
                        xcross = args[i].substring(9, args[i].length());
                    } else if (args[i].startsWith("--arch=")) {
                        arch = args[i].substring(7, args[i].length());
                    } else if (args[i].startsWith("--project=")) {
                        project = args[i].substring(10, args[i].length());
                    } else {
                        _system_.consoleWrite("unknow args:" + args[i] + "\n");
                        printfHelp();
                        return false;
                    }
                }
            }
        }

        return true;
    }

    public void printfHelp() {
        _system_.consoleWrite("\nXStudio build command:\n" +
                              "e.g XStudio -build <options>\n" +
                              "--config=<Config Name>\n" +
                              "--targetdir=<target Directory>\n" +
                              "--xcross=<target OS:[windows|linux|darwin]>\n" +
                              "--arch=<target ARCH:[x86|x86_64|arm|arm64|mips]>\n" +
                              "--project=<Project file : *.xprj>\n");
    }
};


class XStudioApp : QApplication {
    public QMainWindow mainWindow;
    public XWndClass wndclass ;
    public XWndSln wndsln;
    public XStackInfor wndStack;
    public XWndOutput wndOutput;
    public XWndInfor wndInfor;
    public XFindresWnd findWnd;
    public AutoWnd autoWndInfo;
    public WatchWnd watchWndInfo;
    public BreakPointWnd bpWndInfo;
    public XMemoryWnd memoryWnd;
    public XLogcatWnd logcatWnd;
    public XWndObjectDump xDumpWnd;
    public MemoryLookupWnd memlookupWnd;
    public XFindDlg finddlg;
    public CodeTips __tipsWnd;
    static String [] _appargs;
    public static XStudioApp _theApp;
    public static String lastTask = nilptr;
    public static StatusBarMgr statusBar = new StatusBarMgr();

    public XWorkspace _mdispace;
    public XMenuManager menuMgr = new XMenuManager();

    void finalize()override {
        super.finalize();
    }

    public IXStudioController _xstudio_controller = new IXStudioController() {
        WorkspaceController getWorkspace()override {
            if (_mdispace != nilptr) {
                return _mdispace.getController();
            }

            return nilptr;
        }
    };

    Object onCreateXObject(long object,@NotNilptr String objectClass) {
        if (objectClass.equals("QMdiArea")) {
            return new XWorkspace(object);
        }

        return super.onCreateXObject(object, objectClass);
    }

    //创建面板
    void createDocks() {
        wndclass = (XWndClass)mainWindow.attachByName(new XWndClass(), "wnd_classview");
        wndsln = (XWndSln)mainWindow.attachByName(new XWndSln(), "wnd_slnview");
        wndOutput = (XWndOutput)mainWindow.attachByName(new XWndOutput(), "wnd_output");
        wndInfor = (XWndInfor)mainWindow.attachByName(new XWndInfor(), "wnd_info");
        wndStack = (XStackInfor)mainWindow.attachByName(new XStackInfor(), "stackinfo");
        autoWndInfo = (AutoWnd)mainWindow.attachByName(new AutoWnd(), "autoinfo");
        watchWndInfo = (WatchWnd)mainWindow.attachByName(new WatchWnd(), "watchinfo");
        bpWndInfo = (BreakPointWnd)mainWindow.attachByName(new BreakPointWnd(), "bpinfo");
        memlookupWnd = (MemoryLookupWnd)mainWindow.attachByName(new MemoryLookupWnd(), "memlookup");
        finddlg = (XFindDlg)mainWindow.attachByName(new XFindDlg(), "findwnd");
        findWnd = (XFindresWnd)mainWindow.attachByName(new XFindresWnd(), "findinfo");
        memoryWnd = (XMemoryWnd)mainWindow.attachByName(new XMemoryWnd(), "memoryinfo");
        logcatWnd = (XLogcatWnd)mainWindow.attachByName(new XLogcatWnd(), "wnd_log");
        xDumpWnd  = (XWndObjectDump)mainWindow.attachByName(new XWndObjectDump(), "gcinfo");
    }


    public void reconfig() {
        loadConfig();
        wndOutput.reconfig();
        XSourceEditor.reconfig();
        XMemoryWnd.reconfig();
        memlookupWnd.reconfig();
        mainWindow.setMinimumSize(0,0);
    }

    public void loadConfig() {
        if (Setting.isDarkStyle()) {
            setStyleSheet("res/qss/black.qss");
//            __tipsWnd.setStyleSheetString("#tipsForm {background: #e0e0e0 ;border: 1px solid #c3c3c3; }");
        } else {
            String style = Setting.getStyle();
            if (style.equals("浅色")){
                setStyleSheet("res/qss/light.qss");
 //               __tipsWnd.setStyleSheetString("#tipsForm {background: #e0e0e0 ;border: 1px solid #c3c3c3; }");
            }else{
                setStyleSheetString("#indexForm {background: #f0f0f0 }\n#tipsForm {background: #f5f7fe ;border: 1px solid #9ba7b7; border-radius: 5px;}");
            }
        }
    }


    public void processArgs() {
        if (_appargs.length > 1) {
            if (_appargs[1].equals("uacdebug")) {
                if (nilptr != _mdispace.loadProject(_appargs[2])) {
                    _mdispace.debugRun();
                }
            } else {
                _mdispace.openFile(_appargs[1]);
            }
        }
    }

    public bool createWorkspace() {
        mainWindow = new QMainWindow();
        /*Resource.getData(Resource.RES_MAINWINDOW)*/
        if (mainWindow.load(UIManager.getUIData(__xPackageResource("ui/mainwindow.ui"))) == false) {
            return false;
        }
        
        mainWindow.setAcceptDrops(true);
        loadConfig();

        //setPaletteColor("#F0F0F0");
        /*mainWindow.setOnActivateListener(new onActivateListener(){
            void onWindowActivate(QObject obj){
                ((QWidget)obj).setOpacity(1.0);
            }
            void onWindowDeactivate(QObject obj){
                ((QWidget)obj).setOpacity(0.8);
            }
        });*/

        menuMgr.init(this);
        _mdispace = (XWorkspace)mainWindow.findByName("mdiArea");
        if (_mdispace == nilptr){
            return false;
        }
        
        createDocks();

        __tipsWnd = CodeTips.createTips(mainWindow);
        __tipsWnd.hide();
        __nilptr_safe(_mdispace);
        _mdispace.setMainWindow(mainWindow);
        _mdispace.setSlnView(wndsln);
        _mdispace.setStackView(wndStack);
        _mdispace.setupOnDrag(_mdispace);
        _mdispace.setupOnDrag(mainWindow);
        wndclass.workspace = _mdispace;

        /*mainWindow.getCentralWindow().setOnLayoutEventListener(new onLayoutEventListener(){
                void onResize(QObject obj, int w, int h, int oldw, int oldh)override {
                    if (_mdispace != nilptr){
                        _mdispace.resize(w, h);
                    }
                }
        }); */

        //mainWindow.resize(800, 600);
        ProjectPropManager.registryAllProp();
        statusBar.create(mainWindow);
        mainWindow.show();

        Utils.chechUpdate(0);
        //setStyle("Fusion");
        mainWindow.setOnStatusListener(new onStatusListener() {
            bool onClose(QObject obj) {
                if (XSourceEditor.closeAllWindows()) {
                    if (_mdispace.requestQuit()) {
                        _mdispace.closeIndexPage();
                        String statefile = XPlatform.getAppDirectory().appendPath("x.save");

                        try {
                            byte [] state = mainWindow.saveState();

                            if (state != nilptr) {
                                FileOutputStream fos = new FileOutputStream(statefile);
                                fos.write(state);
                                fos.close();
                            }
                        } catch (Exception e) {

                        }

                        if (XStudioApp.lastTask != nilptr) {
                            if (false == openLocal(XStudioApp.lastTask)) {
                                QMessageBox.Critical("失败", "未能以提升的权限运行, 请重试或者确认操作无误.", QMessageBox.Ok, QMessageBox.Ok);
                                return false;
                            }
                        }
                        
                        if (PluginsController.exitPlugins() == false){
                            return false;
                        }
                        return true;
                    }
                }

                return false;
            }
        });


        wndInfor._mdi_area = _mdispace;
        Builder.output = wndOutput;
        Builder.infownd = wndInfor;
        XMenuManager.setProjectLoaded(false);
        XMenuManager.setDocumentOpened(false);
        
        try{
            loadPlugins();
        }catch(Exception e){
            
        }
        
        wndsln.createContextMenu();
        wndclass.createContextMenu();
        
        String statefile = XPlatform.getAppDirectory().appendPath("x.save");

        try {
            FileInputStream fis = new FileInputStream(statefile);
            byte []data = fis.read();

            if (data != nilptr) {
                mainWindow.loadState(data);
            }

            fis.close();
        } catch (Exception e) {

        }

        

        if (Setting.welcomeOnStart()){
            _mdispace.openIndexPage();
        }
        
        processArgs();
        Setting.applySetting();
        
        _system_.registryCrashHandler( new ICrashHandler(){
            void onCrash(String message)override{
            
               String crashfile = "crash_" + _system_.currentTimeMillis() + ".log";
               long hcrash = _system_.openFile(crashfile,"w");
               if (hcrash != 0){
                   byte [] data = message.getBytes();
                   _system_.writeFile(hcrash,data,0,data.length);
                   _system_.closeFile(hcrash);
               }
               
                mainWindow.runOnUi(new Runnable(){
                   void run() override{
                       QMessageBox.Warning("注意","XStudio 内部发生了一个不可挽回的错误并即将退出.\n详细信息已保存到应用目录下的log文件中:\n" + message,QMessageBox.Ok,QMessageBox.Ok);
                       mainWindow.close();
                   }
                });
            }
        });
        return true;
    }

    public void loadPlugins() throws IllegalArgumentException {
        ExtensionManager.load();
        
        FSObject fp = new FSObject(_system_.getAppDirectory().appendPath("plugins"));
        
        long hfind = fp.openDir();
        if (hfind !=0){
            FSObject pfile = new FSObject();
            while (fp.findObject(hfind, pfile)){
                try {
                    if (pfile.isDir() == false) {
                        _system_.loadLibrary(pfile.getPath());
                    }
                } catch (Exception e) {
                    wndOutput.Output( "初始化扩展失败:" + pfile.getPath() + " \t[Exception Message:" + e.getMessage() + "]\n",0);
                }
            }
            fp.closeDir(hfind);
        }
        
        PluginsController.initPlugins(_xstudio_controller);
    }


        
    public bool preprocessArgs() {
        if (_appargs.length > 1) {
            if (_appargs[1].equals("-installpkg")) {
                loadConfig();
                PackageViewer.Install(_appargs[2]);
                return true;
            }
        }

        return false;
    }

    public bool create() {
        if (super.createQApplication()) {
            loadTranslator("translator/qt_zh_CN.qm");

            _theApp = this;

            if (Recently.isFirstRun()) {
                return FirstPrepare.showFirstRun(this);
            } else {
                if (preprocessArgs()) {
                    return true;
                }

                return createWorkspace();
            }
        }

        return false;
    }


    public static void runConsoleBuild(@NotNilptr ArgsProcessor argspro) {
        _system_.createConsole();
        
        bool bParsed = false;
        
        try{
            bParsed = argspro.parse();
        }catch(Exception e){
            
        }
        
        if (bParsed) {
            Project proj = new Project();
            Builder _builder = new Builder(true);
            ProjectPropManager.registryAllProp();

            if (proj.loadWorkspace(argspro.project, true)) {

                if (argspro.configure != nilptr) {
                    if (false == proj.setCurrentConfigure(argspro.configure, false)) {
                        _system_.consoleWrite(XPlatform.converToPlatformCharSet("\n项目不包含配置:" + argspro.configure) + "\n");
                        return ;
                    }
                }
                
                Configure cconfig = proj.getCurrentConfig();
                
                if (cconfig != nilptr){
                    if (argspro.targetpath != nilptr) {
                        cconfig.setOption("outpath", argspro.targetpath);
                    }

                    if (argspro.arch != nilptr) {
                        cconfig.setOption("wtype", "-arch:" + argspro.arch);
                    }

                    if (argspro.xcross != nilptr) {
                        cconfig.setOption("ostype", "-xcross-" + argspro.xcross);
                    }
                }
                
                proj.thread_build(_builder, new BuildListener() {
                    void onBuild(bool success)override {
                        _system_.consoleWrite(XPlatform.converToPlatformCharSet("\n组建" + (success ? "已执行." : "未能执行.") + "\n"));
                    }

                }, nilptr);
            }
        }
    }

    public static int main(@NotNilptr String [] args) {
        _system_.chdir(_system_.getAppDirectory());
        //_system_.disableZGC(true);
        ArgsProcessor argspro = new ArgsProcessor(args);

        if (argspro.getCommand() == ArgsProcessor.CMD_BUILD) {
            runConsoleBuild(argspro);
            return 0;
        }

        XStudioApp app = new XStudioApp();
        XStudioApp._appargs = args;
 
        if (app.create()) {
            app.run();
        }
        
        app = nilptr;
        return 0;
    }

};