Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.erp.core.common.ui;

import org.openconcerto.sql.model.DBRoot;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLRowAccessor;
import org.openconcerto.sql.model.SQLRowValues;
import org.openconcerto.sql.model.SQLRowValuesListFetcher;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.Where;

import java.awt.Color;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;

public class AjoutDeclinaisonTableModel extends AbstractTableModel {
    private List<String> nomsVariants1 = new ArrayList<>();
    private List<String> nomsVariants2 = new ArrayList<>();
    // null si la variante n'existe pas
    private Integer[][] quantites = new Integer[0][0];
    private SQLRowValues[][] articles = new SQLRowValues[0][0];

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        if (columnIndex == 0) {
            return String.class;
        }
        return Integer.class;
    }

    @Override
    public String getColumnName(int column) {
        if (column == 0) {
            return "";
        }
        return this.nomsVariants2.get(column - 1);
    }

    @Override
    public int getRowCount() {
        return this.nomsVariants1.size();
    }

    @Override
    public int getColumnCount() {
        return this.nomsVariants2.size() + 1;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        if (columnIndex == 0)
            return this.nomsVariants1.get(rowIndex);

        return this.quantites[rowIndex][columnIndex - 1];
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        if (columnIndex > 0) {
            if (aValue == null) {
                this.quantites[rowIndex][columnIndex - 1] = 0;
            } else {
                int qte = (Integer) aValue;
                if (qte < 0) {
                    qte = 0;
                }
                this.quantites[rowIndex][columnIndex - 1] = qte;
            }
        }
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        if (columnIndex == 0)
            return false;
        return this.quantites[rowIndex][columnIndex - 1] != null;
    }

    public boolean isMissing(int rowIndex, int columnIndex) {
        if (columnIndex == 0)
            return false;
        return this.quantites[rowIndex][columnIndex - 1] == null;
    }

    public List<SQLRowValues> getFilledArticles(SQLTable tableItem) {
        if (!SwingUtilities.isEventDispatchThread()) {
            throw new IllegalStateException("must be called from EDT");
        }
        System.err.println("AjoutDeclinaisonTableModel.getFilledArticles() table of items :" + tableItem);
        final List<SQLRowValues> result = new ArrayList<>();
        final int s1 = this.nomsVariants1.size();
        final int s2 = this.nomsVariants2.size();
        for (int i = 0; i < s1; i++) {
            for (int j = 0; j < s2; j++) {
                Integer qte = this.quantites[i][j];
                if (qte != null && qte > 0) {
                    final int quantite = qte;
                    final int idArticle = this.articles[i][j].getID();
                    final SQLRowValues r = new SQLRowValues(tableItem);
                    r.put("QTE", quantite);
                    r.put("ID_ARTICLE", idArticle);
                    result.add(r);
                    System.err.println("AjoutDeclinaisonTableModel.getFilledArticles() : " + r);
                }
            }
        }

        return result;
    }

    public void loadFrom(DBRoot root, SQLRow pere, SQLField variant1, SQLField variant2, final JTable table) {
        if (SwingUtilities.isEventDispatchThread()) {
            throw new IllegalStateException("must be called outsite from EDT");
        }

        final SQLTable tArticle = root.getTable("ARTICLE");
        if (!pere.getTable().equals(tArticle)) {
            throw new IllegalStateException(pere + " is not from " + tArticle);
        }

        final SQLRowValues graph = new SQLRowValues(tArticle);
        graph.putRowValues(variant1.getFieldName()).putNulls("NOM", "ORDRE");
        graph.putRowValues(variant2.getFieldName()).putNulls("NOM", "ORDRE");
        final SQLRowValuesListFetcher fetcher = new SQLRowValuesListFetcher(graph);
        Where w = new Where(tArticle.getField("ID_ARTICLE_VIRTUEL_PERE"), "=", pere.getID());
        w = w.and(new Where(tArticle.getField("OBSOLETE"), "=", Boolean.FALSE));
        final List<SQLRowValues> values = fetcher.fetch(w);
        System.err.println("AjoutDeclinaisonTableModel.loadFrom() pere :" + pere);
        System.err.println("AjoutDeclinaisonTableModel.loadFrom() tables des variantes : " + variant1.getTable().getName() + " " + variant2.getTable().getName());
        System.err.println(values.size() + " articles : ");
        for (SQLRowValues r : values) {
            System.err.println(r);
        }
        // Set<String> nomsVariants1 = new HashSet<>();
        final List<SQLRowAccessor> rowsVariant1 = new ArrayList<SQLRowAccessor>();
        final List<SQLRowAccessor> rowsVariant2 = new ArrayList<SQLRowAccessor>();
        for (SQLRowValues r : values) {
            final SQLRowAccessor v1 = r.getForeign(variant1.getFieldName());
            if (v1 != null)
                rowsVariant1.add(v1);
            final SQLRowAccessor v2 = r.getForeign(variant2.getFieldName());
            if (v2 != null)
                rowsVariant2.add(v2);
        }

        // Classement des variants
        final Comparator<SQLRowAccessor> comparator = new Comparator<SQLRowAccessor>() {

            @Override
            public int compare(SQLRowAccessor o1, SQLRowAccessor o2) {
                return o1.getBigDecimal("ORDRE").compareTo(o2.getBigDecimal("ORDRE"));
            }
        };
        Collections.sort(rowsVariant1, comparator);
        Collections.sort(rowsVariant2, comparator);
        // Liste unique et classée des variants 1
        final List<String> tNomsVariants1 = new ArrayList<>();
        final Set<String> tNomsVariants1s = new HashSet<>();
        // ID - index
        final Map<Integer, Integer> mapVariants1 = new HashMap<>();

        int index = 0;
        for (SQLRowAccessor r : rowsVariant1) {
            final String nom = r.getString("NOM");
            if (!tNomsVariants1s.contains(nom)) {
                tNomsVariants1s.add(nom);
                tNomsVariants1.add(nom);
                mapVariants1.put(r.getID(), index);
                index++;
            }
        }
        index = 0;
        // Liste unique et classée des variants 2
        final List<String> tNomsVariants2 = new ArrayList<>();
        final Set<String> tNomsVariants2s = new HashSet<>();
        // ID - index
        final Map<Integer, Integer> mapVariants2 = new HashMap<>();
        for (SQLRowAccessor r : rowsVariant2) {
            final String nom = r.getString("NOM");
            if (!tNomsVariants2s.contains(nom)) {
                tNomsVariants2s.add(nom);
                tNomsVariants2.add(nom);
                mapVariants2.put(r.getID(), index);
                index++;
            }
        }
        System.err.println("AjoutDeclinaisonTableModel.loadFrom() variants 1 : " + tNomsVariants1);
        System.err.println("AjoutDeclinaisonTableModel.loadFrom() variants 2 : " + tNomsVariants2);
        final Integer[][] tQuantites = new Integer[tNomsVariants1.size()][tNomsVariants2.size()];
        final SQLRowValues[][] tArticles = new SQLRowValues[tNomsVariants1.size()][tNomsVariants2.size()];
        for (SQLRowValues r : values) {
            final SQLRowAccessor v1 = r.getForeign(variant1.getFieldName());
            final SQLRowAccessor v2 = r.getForeign(variant2.getFieldName());
            if (v1 != null && v2 != null) {
                final Integer idVariant1 = v1.getID();
                final Integer idVariant2 = v2.getID();
                final int indexVariant1 = mapVariants1.get(idVariant1);
                final int indexVairant2 = mapVariants2.get(idVariant2);
                tQuantites[indexVariant1][indexVairant2] = 0;
                tArticles[indexVariant1][indexVairant2] = r;
            }
        }
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                AjoutDeclinaisonTableModel.this.nomsVariants1.clear();
                AjoutDeclinaisonTableModel.this.nomsVariants1.addAll(tNomsVariants1);
                AjoutDeclinaisonTableModel.this.nomsVariants2.clear();
                AjoutDeclinaisonTableModel.this.nomsVariants2.addAll(tNomsVariants2);
                AjoutDeclinaisonTableModel.this.quantites = tQuantites;
                AjoutDeclinaisonTableModel.this.articles = tArticles;

                fireTableStructureChanged();
                table.getColumnModel().getColumn(0).setCellRenderer(new DefaultTableCellRenderer() {

                    @Override
                    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                        DefaultTableCellRenderer c = (DefaultTableCellRenderer) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                        if (!isSelected) {
                            c.setBackground(new Color(250, 250, 250));
                            c.setForeground(Color.BLACK);
                        }
                        return c;
                    }
                });
                for (int i = 0; i < tNomsVariants2.size(); i++) {
                    table.getColumnModel().getColumn(i + 1).setCellRenderer(new DefaultTableCellRenderer() {

                        @Override
                        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                            DefaultTableCellRenderer c = (DefaultTableCellRenderer) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);

                            if (value == null) {
                                c.setText("");
                                c.setBackground(Color.LIGHT_GRAY);
                            } else {
                                if (!isSelected) {
                                    c.setBackground(Color.WHITE);
                                    c.setForeground(Color.BLACK);
                                }
                                c.setHorizontalAlignment(SwingConstants.RIGHT);
                            }

                            return c;
                        }
                    });
                }

                fireTableDataChanged();
                if (tNomsVariants1.isEmpty() || tNomsVariants2.isEmpty()) {
                    JOptionPane.showMessageDialog(null, "Aucune variante trouvée pour cet article");
                }

            }
        });

    }
}