package gudusoft.gsqlparser.dlineage.metadata;

import java.util.ArrayList;
import java.util.List;

import gudusoft.gsqlparser.util.SQLUtil;

public class Schema extends TreeNode {

    private String name;
    private List<Synonym> synonyms;
    private List<Sequence> sequences;
    private List<Table> tables;
    private List<Table> views;
    private List<Table> others;
    private List<Package> packages;
    private List<Procedure> procedures;
    private List<Procedure> functions;
    private List<Procedure> triggers;
    private List<Process> processes;

    public String getName() {
        return name;
    }

        public void setName(String name) {
                if (SQLUtil.parseNames(name).size() > 1) {
                        name = "\"" + name + "\"";
                }
                this.name = name;
        }

    public List<Table> getTables() {
        return tables;
    }

    public List<Table> getViews() {
        return views;
    }

    public void appendTables(List<Table> tables) {
        if (tables == null) {
            return;
        }

        List<Table> tableList = new ArrayList<Table>();
        List<Table> viewList = new ArrayList<Table>();
        List<Table> otherList = new ArrayList<Table>();
        for (Table table : tables) {
            if (table.getType() == null) {
                continue;
            }
            if ("view".equalsIgnoreCase(table.getType()) || "materialized view".equalsIgnoreCase(table.getType())) {
                viewList.add(table);
            } else if ("table".equalsIgnoreCase(table.getType())) {
                tableList.add(table);
            } else {
                otherList.add(table);
            }
        }

        if (!tableList.isEmpty()) {
            if (this.tables != null) {
                this.tables.addAll(tableList);
            } else {
                this.tables = tableList;
            }
        }

        if (!viewList.isEmpty()) {
            if (this.views != null) {
                this.views.addAll(viewList);
            } else {
                this.views = viewList;
            }
        }

        if (!otherList.isEmpty()) {
            if (this.others != null) {
                this.others.addAll(otherList);
            } else {
                this.others = otherList;
            }
        }
    }

    public void appendViews(List<Table> views) {
        if (views == null) {
            return;
        }

        List<Table> viewList = new ArrayList<Table>();
        for (Table table : views) {
            if (table.getType() == null) {
                continue;
            }
            if ("view".equalsIgnoreCase(table.getType()) || "materialized view".equalsIgnoreCase(table.getType())) {
                viewList.add(table);
            }
        }

        if (!viewList.isEmpty()) {
            if (this.views != null) {
                this.views.addAll(viewList);
            } else {
                this.views = viewList;
            }
        }
    }

    public List<Synonym> getSynonyms() {
        return synonyms;
    }

    public void setSynonyms(List<Synonym> synonyms) {
        if (this.synonyms != null) {
            this.synonyms.addAll(synonyms);
        } else {
            this.synonyms = synonyms;
        }
    }

    public List<Sequence> getSequences() {
        return sequences;
    }

    public void setSequences(List<Sequence> sequences) {
        if (this.sequences != null) {
            this.sequences.addAll(sequences);
        } else {
            this.sequences = sequences;
        }
    }

    public List<Package> getPackages() {
        return packages;
    }

    public void setPackages(List<Package> packages) {
        if (this.packages != null) {
            this.packages.addAll(packages);
        } else {
            this.packages = packages;
        }
    }

    public List<Procedure> getProcedures() {
        return procedures;
    }

    public void setProcedures(List<Procedure> procedures) {
        if (this.procedures != null) {
            this.procedures.addAll(procedures);
        } else {
            this.procedures = procedures;
        }
    }

    public List<Procedure> getFunctions() {
        return functions;
    }

    public void setFunctions(List<Procedure> functions) {
        if (this.functions != null) {
            this.functions.addAll(functions);
        } else {
            this.functions = functions;
        }
    }

    public List<Procedure> getTriggers() {
        return triggers;
    }

    public void setTriggers(List<Procedure> triggers) {
        if (this.triggers != null) {
            this.triggers.addAll(triggers);
        } else {
            this.triggers = triggers;
        }
    }

    public void appendTable(Table table) {
        if (table == null || table.getType() == null) {
            return;
        }
        if ("view".equalsIgnoreCase(table.getType()) || "materialized view".equalsIgnoreCase(table.getType())) {
            if (views == null) {
                views = new ArrayList<Table>();
            }
            views.add(table);
        } else if ("table".equalsIgnoreCase(table.getType())) {
            if (tables == null) {
                tables = new ArrayList<Table>();
            }
            tables.add(table);
        } else {
            if (others == null) {
                others = new ArrayList<Table>();
            }
            others.add(table);
        }
    }

    public void appendPackage(Package oraclePackage) {
        if (packages == null) {
            packages = new ArrayList<Package>();
        }
        packages.add(oraclePackage);
    }

    public void appendProcedure(Procedure procedure) {
        if (procedure == null || procedure.getType() == null) {
            return;
        }
        if (procedure.getType().toLowerCase().indexOf("function") != -1) {
            if (functions == null) {
                functions = new ArrayList<Procedure>();
            }
            procedure.setType("function");
            functions.add(procedure);
        } else if (procedure.getType().toLowerCase().indexOf("trigger") != -1) {
            if (triggers == null) {
                triggers = new ArrayList<Procedure>();
            }
            procedure.setType("trigger");
            triggers.add(procedure);
        } else {
            if (procedures == null) {
                procedures = new ArrayList<Procedure>();
            }
            procedure.setType("procedure");
            procedures.add(procedure);
        }
    }

    public List<Table> getOthers() {
        return others;
    }

    public void appendOthers(List<Table> others) {
        if (!others.isEmpty()) {
            if (this.others != null) {
                this.others.addAll(others);
            } else {
                this.others = others;
            }
        }
    }

    public void setTables(List<Table> tables) {
        this.tables = tables;
    }

    public void setViews(List<Table> views) {
        this.views = views;
    }

    public void setOthers(List<Table> others) {
        this.others = others;
    }

    public List<Process> getProcesses() {
        return processes;
    }

    public void setProcesses(List<Process> processes) {
        this.processes = processes;
    }

    public void appendProcess(Process process) {
        if (process == null) {
            return;
        }
        if (processes == null) {
            processes = new ArrayList<Process>();
        }
        processes.add(process);
    }
}