package g2.data.transact.imp.ui;

import g2.Global;
import g2.data.transact.imp.LogImportHelper;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

import javax.swing.AbstractCellEditor;
import javax.swing.BorderFactory;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableColumn;

@SuppressWarnings({ "serial", "unchecked" })
public class longitudePanel extends JPanel {
public longitudePanel() {

LogImportHelper.prepareFullyProcessedWellGroups();

mainPanel = new JPanel();

existingProperties = new TreeSet(new Comparator() {
public int compare(Object first, Object other) {
if (((String) first).equalsIgnoreCase(((String) other)))
return 0;
return ((String) first).compareTo(((String) other));
}
});

basicInformation = new JLabel(
"The Import Wizard has found "
+ "following properties from the file(s) you selected. Please "
+ "select corresponding property from the project (If Any)..."
+ "");

mainPanel.setLayout(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);
gbc.fill = GridBagConstraints.BOTH;
gbc.weightx = 0.1;
gbc.weighty = 0.001;
gbc.gridwidth = GridBagConstraints.REMAINDER;

wellGroups = LogImportHelper.getFullyProcessedWellGroups();

Map props = Global.LOG_PROPERTIES;
List existingVariableList = new ArrayList(10);

for (int i = 0; i < props.size(); i++) {
String nextVariable = (String) props.get("Properties_" + (i + 1));
String nextProperty = Global.properties.getProperty(nextVariable);
try {
if (nextProperty.equalsIgnoreCase("Measured Depth (MD)")) {
continue;
} else {
existingVariableList.add(nextVariable);
}
} catch (NullPointerException exp) {
existingVariableList.add(nextVariable);
continue;
}
}

String[] existingVariables = (String[]) existingVariableList
.toArray(new String[0]);

Arrays.sort(existingVariables);

tableData = new Object[wellGroups.length][][];

/**
* boolean added to stop items to be added in each iteration instead it
* should be added just after successive iterations
*/

boolean firstTime = true;

gbc.weighty = 0.999 / wellGroups.length;

allTables = new JTable[wellGroups.length];

for (int i = 0; i < wellGroups.length; i++) {
Object wellGroupNull = wellGroups[i];
if (wellGroupNull == null)
continue;

JPanel innerPanel = new JPanel(new BorderLayout());

String[] columnNames = { "Variables From File(s)",
"Existing Properties", "Variables From Project" };

String[] uniqueProperties = wellGroups[i].getUniquePropsNames();

tableData[i] = new Object[uniqueProperties.length][3];

JComboBox[] existingPropsComboBox = new JComboBox[uniqueProperties.length];

for (int j = 0; j < uniqueProperties.length; j++) {

existingPropsComboBox[j] = new JComboBox(existingVariables);
existingPropsComboBox[j].insertItemAt("Unknown", 0);

tableData[i][j][0] = uniqueProperties[j];

/*
* Add all properties that were there in the last block as
* during import all these properties in the last block would
* have been added in the project before importing this block.
*/

if (!firstTime) {
String[] alreadyVirtualExistingProps = (String[]) existingProperties
.toArray(new String[0]);
for (int k = 0; k < alreadyVirtualExistingProps.length; k++) {
existingPropsComboBox[j]
.addItem(alreadyVirtualExistingProps[k]);
}
}

/*
* If this property has already been shown as unknown in the
* above tables then it should also be displayed in the mapped
* section. Same variables appearing one than once in a single
* file will break this code.
*/

if (!existingProperties.add(uniqueProperties[j])) {
tableData[i][j][2] = uniqueProperties[j];
existingPropsComboBox[j]
.setSelectedItem(uniqueProperties[j]);
tableData[i][j][1] = Global.properties
.getProperty(uniqueProperties[j]);
tableData[i][j][1] = (tableData[i][j][1] == null ? "Unknown"
: tableData[i][j][1]);

/*
* Forcefully removing "Unknown" entry as this would cause
* problem by trying to create a new variable with the same
* name as, some existing one.
*/

if (!tableData[i][j][2].toString().equalsIgnoreCase(
"Unknown"))
existingPropsComboBox[j].removeItem("Unknown");

} else {
tableData[i][j][1] = "Unknown";
existingPropsComboBox[j].setSelectedItem("Unknown");
tableData[i][j][2] = "Unknown";
}
for (int k = 0; k < existingVariables.length; k++) {
if (existingVariables[k]
.equalsIgnoreCase(uniqueProperties[j])) {
tableData[i][j][2] = existingVariables[k];
existingPropsComboBox[j]
.setSelectedItem(existingVariables[k]);
tableData[i][j][1] = Global.properties
.getProperty(existingVariables[k]);
tableData[i][j][1] = (tableData[i][j][1] == null ? "Unknown"
: tableData[i][j][1]);

/*
* Forcefully removing "Unknown" entry as this would
* cause problem by trying to create a new variable with
* the same name as, some existing one.
*/

if (!tableData[i][j][2].toString().equalsIgnoreCase(
"Unknown"))
existingPropsComboBox[j].removeItem("Unknown");
}
}
}

firstTime = false;

AliasTableModel aliasModel = new AliasTableModel(tableData[i],
columnNames, i);
aliasModel.addTableModelListener(new AliasTableListener(
wellGroups[i].getWellString(), i));
allTables[i] = new JTable(aliasModel);

TableColumn existingPropsColumn = allTables[i].getColumnModel()
.getColumn(2);
PropertiesEditor editor = new PropertiesEditor(
existingPropsComboBox, i);
existingPropsColumn.setCellEditor(editor);

LogImportHelper.prepareMappings(wellGroups[i].getWellString(),
tableData[i]);

allTables[i].setPreferredScrollableViewportSize(new Dimension(
allTables[i].getWidth(), allTables[i].getRowCount()
* (allTables[i].getRowHeight()
+ allTables[i].getRowMargin() + 10)));

allTables[i].setRowHeight(25);

JTableHeader header = allTables[i].getTableHeader();
header.setReorderingAllowed(false);

// innerPanel.add(new JScrollPane(allTables[i]));
// innerPanel.setBorder(BorderFactory.createTitledBorder(wellGroups[i]
// .getWellString()));
// mainPanel.add(innerPanel, gbc);
}
JPanel innerPanel = new JPanel();

JTable myTable = new JTable(new MyTableModel());
innerPanel.add(new JScrollPane(myTable));

innerPanel.setBorder(BorderFactory.createTitledBorder(wellGroups[0]
.getWellString()));
mainPanel.add(innerPanel, gbc);
this.setLayout(new BorderLayout());
((BorderLayout) this.getLayout()).setVgap(10);
this.add(basicInformation, "North");
this.add(new JScrollPane(mainPanel), "Center");
}

public void commitChanges(Container c) {
if (c == null)
c = this;
Component[] allComps = c.getComponents();
for (int i = 0; i < allComps.length; i++) {
if (allComps[i] instanceof Container) {
commitChanges((Container) allComps[i]);
}
if (allComps[i] instanceof JTable) {
JTable table = (JTable) allComps[i];
TableCellEditor edit = table.getCellEditor();
if (edit != null)
edit.stopCellEditing();
break;
}
}
}

public void resetProcess() {
;
}

private class AliasTableModel extends DefaultTableModel {
/**
* Default Serial version UID: Only to remove UID
*/
private static final long serialVersionUID = 1L;

AliasTableModel(Object[][] data, Object[] columnNames, int tableNumber) {
super(data, columnNames);
this.tableNumber = tableNumber;
}

public boolean isCellEditable(int row, int column) {
return column == 2;
}

public Class getColumnClass(int columnIndex) {
return getValueAt(0, columnIndex).getClass();
}

public void setValueAt(Object value, int row, int col) {
super.setValueAt(value, row, col);
tableData[tableNumber][row][col] = value;
fireTableCellUpdated(row, col);
}

private int tableNumber;
}

private class AliasTableListener implements TableModelListener {
AliasTableListener(String wellString, int tableNumber) {
this.wellString = wellString;
this.tableNumber = tableNumber;
}

public void tableChanged(TableModelEvent event) {
LogImportHelper.prepareMappings(wellString, tableData[tableNumber]);
}

private String wellString;

private int tableNumber;
}

private class PropertiesEditor extends AbstractCellEditor implements
TableCellEditor, ItemListener {

/**
* default serial version UID : only to remove warning.
*/
private static final long serialVersionUID = 1L;

PropertiesEditor(Object component, int table) {
this.component = (JComboBox[]) component;
this.tableNo = table;

for (int i = 0; i < this.component.length; i++) {
this.component[i].addItemListener(this);
}
}

public Component getTableCellEditorComponent(JTable table,
Object value, boolean hasFocus, int row, int column) {
currentValue = value;
return component[row];
}

public Object getCellEditorValue() {
return currentValue;
}

public void itemStateChanged(ItemEvent event) {
JComboBox tempCombo = (JComboBox) event.getSource();
for (int i = 0; i < this.component.length; i++) {
if (this.component[i].equals(tempCombo)) {
currentValue = ((JComboBox) event.getSource())
.getSelectedItem();
tableData[tableNo][i][2] = currentValue;
}
}
TableCellEditor editor = ((TableCellEditor) allTables[tableNo]
.getCellEditor());
if (editor != null)
editor.stopCellEditing();
}

JComboBox[] component;

int tableNo;

Object currentValue;

}

private class MyTableModel extends AbstractTableModel {

MyTableModel() {
init();
}

void init() {
data = new Object[wellGroups.length][coloumNames.length];
int i = 0;
for (LogImportHelper.FullyProcessedWellGroup wellGroup : wellGroups) {
data[i][0] = wellGroup.getWellString();
float x = wellGroup.getMinLocation3D().getX();
float y = wellGroup.getMinLocation3D().getY();
data[i][1] = x;
data[i][2] = y;

if (x == Global.MISSING_LOG || y == Global.MISSING_LOG) {
data[i++][3] = true;
} else {
data[i++][3] = false;
}
}
}

@Override
public int getRowCount() {
return wellGroups.length;
}

@Override
public int getColumnCount() {
return coloumNames.length;
}

@Override
public Object getValueAt(int rowIndex, int columnIndex) {
return data[rowIndex][columnIndex];

}

@Override
public String getColumnName(int column) {
return coloumNames[column];
}

@Override
public Class getColumnClass(int columnIndex) {

if (columnIndex == 3)
return Boolean.class;
return super.getColumnClass(columnIndex);
}

private Object data[][];

private String[] coloumNames = new String[] { "wellName", "surface X ",
" surface Y", "Select" };

}

private Object[][][] tableData;

private JTable[] allTables;

private TreeSet existingProperties;

private JLabel basicInformation;

private JPanel mainPanel;

private LogImportHelper.FullyProcessedWellGroup[] wellGroups;

}
-----------------------------------------------------------------------------------------------------

boolean validateInput7(final int option) {
boolean valid = false;

/*
* LOG: For import of 'Well Logs (X, Y, Z)'
*/

if (option == Import.LOG) {
if (!quickImport) {
this.stepSixPanel.commitChanges(null);
}

if (this.step_count == 5) {
this.stepSevenPanel = new CommonWellInformationPanel();
}

if (this.bypassed) {
this.stepEightPanel = new FinalPanel();
this.main_panel.add("Ninth", this.stepEightPanel);
return false;
}
if (this.step_count == 6) {
if (!quickImport) {
this.stepSevenPanel.commitChanges(null);
}


this.longitudepanel = new longitudePanel();
this.main_panel.add("longitude", this.longitudepanel);
}
if(this.step_count == 7)
{
if (!quickImport) {
this.stepSevenPanel.commitChanges(null);
}


this.stepEightPanel = new FinalPanel();
this.main_panel.add("Ninth", this.stepEightPanel);


}


else {
this.stepSixPanel.commitChanges(null);
this.main_panel.add("Eigth", this.stepSevenPanel);
}
valid = true;
}
return valid;
}
----------------------------------------------------------------------------------------------------


} else if (this.step_count == 6) {
if (this.validateInput7(this.option)) {
++this.step_count;
this.updateMainPanel(this.option);
if (quickImport) {
nextbtn.doClick();
}
}
}



else if (this.step_count == 7) {


if (this.validateInput6(this.option)) {
++this.step_count;
this.updateMainPanel(this.option);
if (quickImport) {
nextbtn.doClick();
}
}

}
}