import com.sun.javafx.perf.PerformanceTracker;
import java.util.ArrayList;
import java.util.List;
import javafx.animation.AnimationTimer;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.collections.*;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.stage.Stage;
import javafx.util.Callback;
import javafx.util.Duration;

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

/**
 *
 * @author ekaterina.pavlova@oracle.com
 */
public class TableViewMemTest extends Application {

    enum TestMode {STATICALL, STATICDATA, STATICCOLS, DYNAMIC };
    static TestMode testMode = TestMode.STATICALL;
    
    static double SCENE_WEIGHT = 800.0;
    static double SCENE_HEIGHT = 600.0;
    static int ROWS = 10;
    static int COLS = 100;

    static ObservableList<List<Double>> staticTableData;
    public void initStaticLines() {
        staticTableData = FXCollections.observableArrayList();
        for (int row = 0; row < ROWS; row++) {
            List<Double> line = new ArrayList<Double>();
            for (int col = 0; col <= COLS; col++) {
                if(col == 0) line.add((double)row);
                else line.add(Math.random() * 1000);
            }
            staticTableData.add(line);
        }
    }

    static List<TableColumn> staticCols;
    public void initStaticColumns() {
        staticCols = new ArrayList<TableColumn>();
        for (int i = 0; i <= COLS; i++) {
            TableColumn col = new TableColumn("Col" + i);
            final int coli = i;
            col.setDataRetriever(new Callback<TableColumn.CellDataFeatures<Double>, Double>() {
                @Override public Double call(TableColumn.CellDataFeatures p) {
                    return ((List<Double>) p.getValue()).get(coli);
                }
            });
            staticCols.add(col);
        }
    }

    public ObservableList<List<Double>> createTableLines() {
        ObservableList<List<Double>> bigData = FXCollections.observableArrayList();;

        for (int row = 0; row < ROWS; row++) {
            List<Double> line = new ArrayList<Double>();
            for (int col = 0; col <= COLS; col++) {
                if(col == 0) line.add((double)row);
                else line.add(Math.random() * 1000);
            }
            bigData.add(line);
        }

        return bigData;
    }

    public List<TableColumn> createTaleColumns() {
        List<TableColumn> cols = new ArrayList<TableColumn>();
        for (int i = 0; i <= COLS; i++) {
            TableColumn col = new TableColumn("Col" + i);
            final int coli = i;
            col.setDataRetriever(new Callback<TableColumn.CellDataFeatures<Double>, Double>() {
                @Override public Double call(TableColumn.CellDataFeatures p) {
                    return ((List<Double>) p.getValue()).get(coli);
                }
            });
            cols.add(col);
        }
        return cols;
    }


    Stage stage;
    PerformanceTracker perfTracker;
    Group rootGroup;
    int iters=1;
    @Override public void start(Stage primaryStage) {
        stage = new Stage();

        rootGroup = new Group();
        Scene scene = new Scene(rootGroup, SCENE_WEIGHT, SCENE_HEIGHT);

        stage.setScene(scene);
        stage.sizeToScene();
        stage.setVisible(true);

        perfTracker = PerformanceTracker.getSceneTracker(scene);

        Timeline fpsTimeline = new Timeline();
        fpsTimeline.setCycleCount(Timeline.INDEFINITE);
        KeyFrame fpsKeyFrame = new KeyFrame(Duration.valueOf(2000), new EventHandler<ActionEvent>() {
            @Override public void handle(ActionEvent e) {
                String fpsText = String.format("FPS: %.2f", perfTracker.getInstantFPS());
                System.out.println(fpsText);
            }
        });
        fpsTimeline.getKeyFrames().add(fpsKeyFrame);

        initStaticLines();
        initStaticColumns();
        
        AnimationTimer objectsAllocator = new AnimationTimer() {
            boolean stop = false;

            @Override
            public void handle(long l) {

                ObservableList<List<Double>> tableData = staticTableData;
                List<TableColumn> tableCols = staticCols;

                if (testMode != TestMode.STATICALL && testMode != TestMode.STATICDATA) {
                    tableData = createTableLines();
                }
                if (testMode != TestMode.STATICALL && testMode != TestMode.STATICCOLS) {
                    tableCols = createTaleColumns();
                }

                stage.setTitle("TableView " + iters);

                TableView tableView = new TableView();
                tableView.getColumns().addAll(tableCols);
                tableView.setPrefSize(SCENE_WEIGHT, SCENE_HEIGHT);
                tableView.setColumnControlEnabled(true);

                tableView.setItems(tableData);

                if (rootGroup.getChildren().size() == 1) {
                    rootGroup.getChildren().remove(0);
                }
                rootGroup.getChildren().add(0, tableView);

                System.out.println("Created " + iters + "th TableView");
                System.out.println("rootGrp size: " + rootGroup.getChildren().size());

//                System.gc(); try { Thread.sleep(100); } catch (Exception e) {}
//                System.gc(); try { Thread.sleep(100); } catch (Exception e) {}

                iters++;
            }
        };
        fpsTimeline.play();
        objectsAllocator.start();
    }

    
    public static void main(String[] args) {
        for (int index = 0; index < args.length; index++) {
            String arg = args[index];

            if ("-mode".equals(arg)) {
                if (index+1 >= args.length) {
                    System.err.println("-mode option requires an argument");
                    System.exit(1);
                }
                try {
                    testMode = TestMode.valueOf(args[index+1].toUpperCase());
                } catch (IllegalArgumentException e) {
                    System.err.print("-mode option must be from {");
                    for (int i=0; i<TestMode.values().length; i++)
                        System.err.print(TestMode.values()[i].toString().toLowerCase() + " ");
                    System.err.println(")");

                    System.exit(1);
                }
                index++;
            }
        }

        System.out.println("Running in mode: " + testMode);
        Application.launch(TableViewMemTest.class, args);
    }

}