/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package gulfpacific;

import gulfpacific.exception.DbNotConnectedException;
import java.lang.Class;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

/**
 *
 * @author charlie
 */
public class CallList1 implements TableModel {

    private Vector<Company> companyList = null;
    private Vector<ImportRecord> importRecordList = null;
    private Vector<ImportFilename> importFilenameList = null;
    private Hashtable<Company, Vector<Contact>> contactList = null;
    private Vector<Column> tableColumns = null;
    private Vector<TableModelListener> tableModelListeners = null;
    private boolean defaultCallList;

    private abstract class Column<T> {

        public Column(String h, Class t) {
            this.heading = h;
            this.type = t;
        }
        private String heading;
        private Class type;

        public String getHeading() {
            return this.heading;
        }

        public abstract T get(Company c);

        public abstract void set(T o, Company c);

        public Class getColumnClass() {
            return this.type;
        }
    }

    public CallList1() {
        this.initialize(false);
    }

    public CallList1(boolean d) {
        this.initialize(d);
    }

    private void initialize(boolean d) {
        this.defaultCallList = d;
        this.tableModelListeners = new Vector<TableModelListener>();
        this.companyList = new Vector<Company>();
        this.importRecordList = new Vector<ImportRecord>();
        this.importFilenameList = new Vector<ImportFilename>();
        this.contactList = new Hashtable<Company, Vector<Contact>>();
        this.tableColumns = new Vector<Column>();
        this.tableColumns.add(new Column<String>("Name", String.class) {

            public String get(Company c) {
                return c.getName();
            }

            public void set(String o, Company c) {
                c.setName(o);
            }
        });
        this.tableColumns.add(new Column<String>("City", String.class) {

            public String get(Company c) {
                return c.getCity();
            }

            public void set(String o, Company c) {
                c.setCity(o);
            }
        });
        this.tableColumns.add(new Column<String>("Volume", String.class) {

            public String get(Company c) {
                return c.getAnnualVolume();
            }

            public void set(String o, Company c) {
                c.setAnnualVolume(o);
            }
        });
        this.tableColumns.add(new Column<String>("SIC", String.class) {

            public String get(Company c) {
                return c.getSicCode();
            }

            public void set(String o, Company c) {
                c.setSicCode(o);
            }
        });
    }

    public void setDefault(boolean d) {
        if (d && !this.defaultCallList) {
            this.companyList.removeAllElements();
            this.importFilenameList.removeAllElements();
            this.importRecordList.removeAllElements();
            this.contactList.clear();
        }
        this.defaultCallList = d;
    }

    private void removeAllListeners() {
        this.tableModelListeners.removeAllElements();
    }

    public boolean isDefault() {
        return this.defaultCallList;
    }

    public int getSize() {
        return this.companyList.size();
    }

    public Iterator<Company> getCompanyIterator() {
        return this.companyList.iterator();
    }

    public Iterator<Contact> getContactIterator(Company com) {
        Vector<Contact> vc = this.contactList.get(com);
        if (vc == null) {
            vc = new Vector<Contact>();
        }
        return vc.iterator();
    }

    public void update() {
        this.sendEvent(new TableModelEvent(this));
    }

    private void sendEvent(TableModelEvent e) {
        Iterator<TableModelListener> i = this.tableModelListeners.iterator();
        while (i.hasNext()) {
            i.next().tableChanged(e);
        }
    }

    public Contact addContact(Company com,
            int order,
            String firstName,
            String lastName,
            String position,
            String gender,
            int id,
            double pctOwner) {
        Contact result = null;
        result = new Contact(com, order, firstName, lastName, position, gender, id, pctOwner);
        Vector<Contact> vc = this.contactList.get(com);
        if (vc == null) {
            vc = new Vector<Contact>();
            this.contactList.put(com, vc);
        }
        vc.add(result);
        return result;
    }

    public Company getCompany(int i) {
        return this.companyList.elementAt(i);
    }

    public void addImportFilename(ImportFilename f) {
        this.importFilenameList.add(f);
    }

    public void addImportRecord(ImportRecord r) {
        this.importRecordList.add(r);
    }

    public ImportRecord getImportRecord(int id) {
        ImportRecord result = null;
        Iterator<ImportRecord> i = this.importRecordList.iterator();
        while (i.hasNext()) {
            ImportRecord r = i.next();
            if (r.getId() == id) {
                result = r;
                break;
            }
        }
        return result;
    }

    public Company addCompany(int id,
            String companyName,
            String companyAddress1,
            String companyAddress2,
            String companyCity,
            String companyState,
            String companyZip,
            String companySicCode,
            String companySicDescription,
            String companyAnnualVolume,
            String companyFtEmployees,
            String companyPtEmployees,
            String companyPhoneAreaCode,
            String companyPhoneExchange,
            String companyPhoneNumber,
            String companyFaxAreaCode,
            String companyFaxExchange,
            String companyFaxNumber,
            String companyTollFreeAreaCode,
            String companyTollFreeExchange,
            String companyTollFreeNumber,
            String companyCellAreaCode,
            String companyCellExchange,
            String companyCellNumber,
            String email,
            String companyCounty,
            ImportRecord importRecord,
            boolean doNotCall,
            String reference) {
        Company co = new Company(id,
                companyName,
                companyAddress1,
                companyAddress2,
                companyCity,
                companyState,
                companyZip,
                companySicCode,
                companySicDescription,
                companyAnnualVolume,
                companyFtEmployees,
                companyPtEmployees,
                companyPhoneAreaCode,
                companyPhoneExchange,
                companyPhoneNumber,
                companyFaxAreaCode,
                companyFaxExchange,
                companyFaxNumber,
                companyTollFreeAreaCode,
                companyTollFreeExchange,
                companyTollFreeNumber,
                companyCellAreaCode,
                companyCellExchange,
                companyCellNumber,
                email,
                companyCounty,
                importRecord,
                doNotCall,
                reference);
        this.companyList.add(co);
        return co;
    }

    // Implements TableModel
    public int getRowCount() {
        int result = 4;
        if (!this.defaultCallList) {
            result = this.companyList.size();
        }
        return result;
    }

    public int getColumnCount() {
        int result = 4;
        if (!this.defaultCallList) {
            result = this.tableColumns.size();
        }
        return result;
    }

    public String getColumnName(int arg0) {
        return this.tableColumns.elementAt(arg0).getHeading();
    }

    public Class<?> getColumnClass(int arg0) {
        return this.tableColumns.elementAt(arg0).getColumnClass();
    }

    public boolean isCellEditable(int arg0, int arg1) {
        return false;
    }

    public Object getValueAt(int row, int column) {
        Object result = null;
        if (!this.defaultCallList) {
            Column cm = this.tableColumns.elementAt(column);
            Company co = this.companyList.elementAt(row);
            result = cm.get(co);
        }
        return result;
    }

    public void setValueAt(Object arg0, int arg1, int arg2) {
        if (!this.defaultCallList) {
            Column cm = this.tableColumns.elementAt(arg2);
            Company co = this.companyList.elementAt(arg1);
            cm.set(arg0, co);
        }
    }

    public void addTableModelListener(TableModelListener arg0) {
        this.tableModelListeners.add(arg0);
    }

    public void removeTableModelListener(TableModelListener arg0) {
        this.tableModelListeners.remove(arg0);
    }
    
    public void doSearch(Database db, int companyId) throws SQLException, DbNotConnectedException {
        this.doSearch(db, "", "", "", "", "", "", "", "", "", companyId);
    }
    
    public void doSearch(Database db, String sicString, String annualVolumeString, String cityString, String zipString,
            String countyString, String sicKeywordsString, String dateImportedString, String importIdString,
            String referenceString) throws SQLException, DbNotConnectedException {
        this.doSearch(db, sicString, annualVolumeString, cityString, zipString, countyString, sicKeywordsString, dateImportedString, importIdString, referenceString, -1);
    }
    

    private void doSearch(Database db, String sicString, String annualVolumeString, String cityString, String zipString,
            String countyString, String sicKeywordsString, String dateImportedString, String importIdString,
            String referenceString, int searchCompanyId) throws SQLException, DbNotConnectedException {
        boolean consistent = true;
        int importId = 0, importFilenameId = 0;
        ImportRecord importRecord = null;
        String importDate = null;
        ImportFilename importFilename = null;
        int importFilenameFileLines = 0;
        String importFilenameFileDate = null;
        String importFilePath = null;
        int companyId = 0;
        StringBuffer query = new StringBuffer("select * from Company inner join Import using (" + Database.importId + ") where ");
        if (searchCompanyId < 0) {
        db.initMakeTerm();
        query.append(db.makeSicTerm(Database.companySicCode, sicString));
        query.append(db.makeAnnualVolumeTerm(Database.companyAnnualVolume, annualVolumeString));
        query.append(db.makeTerm(Database.companyCity, cityString));
        query.append(db.makeTerm(Database.companyZip, zipString));
        query.append(db.makeTerm(Database.companyCounty, countyString));
        query.append(db.makeTerm(Database.companySicDescription, sicKeywordsString));
        query.append(db.makeDateTerm(Database.importDate, dateImportedString));
        query.append(db.makeTerm(Database.importId, importIdString));
        query.append(db.makeTerm(Database.companyReference, referenceString));
        } else {
            query.append(Database.companyId + "='" + searchCompanyId + "'");
        }

        ResultSet rs = db.executeQuery(query.toString());
        rs.beforeFirst();
        this.setDefault(true);
        while (rs.next()) {
            this.setDefault(false);
            importId =
                    db.getImportId(rs);
            importRecord =
                    this.getImportRecord(importId);
            if (importRecord == null) {
                ResultSet idrs = db.executeQuery("select * from Import where " +
                        Database.importId + "='" + importId + "'");
                idrs.beforeFirst();
                if (idrs.next()) {
                    importFilenameId = db.getImportFilenameId(idrs);
                    importDate =
                            db.getImportDate(idrs);
                } else {
                    consistent = false;
                }

            } else {
                importFilename = importRecord.getImportFilename();
                importFilenameId =
                        importFilename.getId();
            }

            if (!consistent) {
                continue;
            }

            if (importFilename == null) {
                ResultSet idrs = db.executeQuery("select * from ImportFilename where " +
                        Database.importFilenameId + "='" + importFilenameId + "'");
                idrs.beforeFirst();
                if (idrs.next()) {
                    importFilenameFileLines = db.getImportFilenameFileLines(idrs);
                    importFilenameFileDate =
                            db.getImportFilenameFileDate(idrs);
                    importFilePath =
                            db.getImportFilenamePathname(idrs);
                } else {
                    consistent = false;
                }

            }
            if (!consistent) {
                continue;
            }

            if (importFilename == null) {
                importFilename = new ImportFilename(importFilenameId,
                        importFilePath,
                        importFilenameFileLines,
                        importFilenameFileDate);
                this.addImportFilename(importFilename);
            }

            if (importRecord == null) {
                importRecord = new ImportRecord(importId,
                        importFilename,
                        importDate);
                this.addImportRecord(importRecord);
            }

            companyId = db.getCompanyId(rs);
            Company theCompany = this.addCompany(companyId,
                    db.getCompanyName(rs),
                    db.getCompanyAddress1(rs),
                    db.getCompanyAddress2(rs),
                    db.getCompanyCity(rs),
                    db.getCompanyState(rs),
                    db.getCompanyZip(rs),
                    db.getCompanySicCode(rs),
                    db.getCompanySicDescription(rs),
                    db.getCompanyAnnualVolume(rs),
                    db.getCompanyFtEmployees(rs),
                    db.getCompanyPtEmployees(rs),
                    db.getCompanyPhoneAreaCode(rs),
                    db.getCompanyPhoneExchange(rs),
                    db.getCompanyPhoneNumber(rs),
                    db.getCompanyFaxAreaCode(rs),
                    db.getCompanyFaxExchange(rs),
                    db.getCompanyFaxNumber(rs),
                    db.getCompanyTollFreeAreaCode(rs),
                    db.getCompanyTollFreeExchange(rs),
                    db.getCompanyTollFreeNumber(rs),
                    db.getCompanyCellAreaCode(rs),
                    db.getCompanyCellExchange(rs),
                    db.getCompanyCellNumber(rs),
                    db.getCompanyEmail(rs),
                    db.getCompanyCounty(rs),
                    importRecord,
                    db.getCompanyDoNotCall(rs),
                    db.getCompanyReference(rs));
            ResultSet rsContact = db.executeQuery("select * from Contact where " +
                    Database.companyId + "='" + companyId + "' " +
                    "order by + " + Database.contactOrder);
            rsContact.beforeFirst();
            int order = 0;
            while (rsContact.next()) {
                this.addContact(theCompany, order,
                        db.getContactFirstName(rsContact),
                        db.getContactLastName(rsContact),
                        db.getContactPosition(rsContact),
                        db.getContactGender(rsContact),
                        db.getContactId(rsContact),
                        db.getContactPctOwnership(rsContact));
                order++;
            }
        }
        this.update();

    }
}