/*
 * Copyright (c) 2014 Paul Scherrer Institute. All rights reserved.
 */
package ch.psi.mxsc;

import ch.psi.pshell.device.Device;
import ch.psi.pshell.device.DeviceBase;
import ch.psi.pshell.device.DeviceConfig;
import ch.psi.pshell.imaging.DimensionDouble;
import ch.psi.pshell.imaging.PointDouble;
import ch.psi.pshell.swing.DevicePanel;
import java.io.IOException;
import java.util.ArrayList;

/**
 *
 */
public class Puck extends DeviceBase {
    
    final static int signalX = -1;
    final static PointDouble[] SAMPLES_POSITION_NORMAL = new PointDouble[]{
        new PointDouble(0 * signalX, 24.24),
        new PointDouble(23.05360995 * signalX, 7.490571944),
        new PointDouble(14.24791452* signalX, -19.61057194),
        new PointDouble(-14.24791452 * signalX, -19.61057194),
        new PointDouble(-23.05360995 * signalX, 7.490571944),
        new PointDouble(0 * signalX, 52.52),
        new PointDouble(28.39445573 * signalX, 44.18263554),
        new PointDouble(47.7738724 * signalX, 21.81759648),
        new PointDouble(51.98542213 * signalX, -7.474375306),
        new PointDouble(39.69196765 * signalX, -34.39328575),
        new PointDouble(14.79659389 * signalX, -50.39257097),
        new PointDouble(-14.79659389 * signalX, -50.39257097),
        new PointDouble(-39.69196765 * signalX, -34.39328575),
        new PointDouble(-51.98542213 * signalX, -7.474375306),
        new PointDouble(-47.7738724 * signalX, 21.81759648),
        new PointDouble(-28.39445573 * signalX, 44.18263554)
    };
    
    final static PointDouble[] SAMPLES_POSITION_RT = new PointDouble[]{
        new PointDouble(-30.0,-40.0),
        new PointDouble(-2.0, -30.0),
        new PointDouble(25.0, -40.0),
        new PointDouble(45.0, -15.0),
        new PointDouble(-30.0,0.0),
        new PointDouble(-30.0, 40.0),
        new PointDouble(-2.0, 30.0),
        new PointDouble(25.0, 40.0),
        new PointDouble(45.0, 15.0)
    };
            
    final static PointDouble[] samplesPosition = (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt) ?
            SAMPLES_POSITION_RT :  SAMPLES_POSITION_NORMAL;
    
    static final Character[] SEGMENTS_NORMAL =new Character[]{
        'A', 'A','A', 'A', 'A',
        'B', 'B', 'B', 'B', 'B',
        'C', 'C', 'C', 'C', 'C',
        'D', 'D', 'D', 'D', 'D',        
        'E', 'E', 'E', 'E', 'E',        
        'F', 'F', 'F', 'F', 'F',        
    };
    
    static final Character[] SEGMENTS_SF = new Character[]{
                       'A', 'A',
        'F', 'F', 'F', 'F', 'F',
        'E', 'E', 'E', 'E', 'E',
        'D', 'D', 'D', 'D', 'D',
        'C', 'C', 'C', 'C', 'C',
        'B', 'B', 'B', 'B', 'B',
        'A', 'A', 'A'} ;      

    static final Character[] SEGMENTS_6D =new Character[]{
        'A', 'A','A', 'A', 'A',
        'B', 'B', 'B', 'B', 'B',
        'C', 'C', 'C', 'C', 'C',
        'D', 'D', 'D', 'D', 'D',        
        'E', 'E', 'E', 'E', 'E',        
        'F', 'F', 'F', 'F', 'F',        
    };    

    static final Character[] SEGMENTS_RT =new Character[]{
        'A', 'B','C', 'D', 'E', 'F'      
    }; 
    
    static final int[] NUMBERS_NORMAL = new int[]{
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
    };
    
    static final int[] NUMBERS_SF = new int[]
                {1, 2,
        5, 4, 3, 1, 2,
        5, 4, 3, 1, 2,
        5, 4, 3, 1, 2,
        5, 4, 3, 1, 2,
        5, 4, 3, 1, 2,
        5, 4, 3};     

    static final int[] NUMBERS_6D = new int[]{
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
        1, 2, 3, 4, 5,
    };
    
    static final int[] NUMBERS_RT = new int[]{
        1, 1, 1, 1, 1, 1
    };    

    static final int[] ADDRESSES_NORMAL = new int[]{
        1, 2, 3, 4, 5,
        6, 7, 8, 9, 10,
        11, 12, 13, 14, 15,        
        16, 17, 18, 19, 20,
        21, 22, 23, 24, 25,
        26, 27, 28, 29, 30
    };
    static final int[] ADDRESSES_SF = new int[]
                {6, 7,
        5, 4, 3, 1, 2,
        20, 19, 18, 16, 17,
        15, 14, 13, 11, 12,
        30, 29, 28, 26, 27,
        25, 24, 23, 21, 22,
        10, 9, 8};
    
    static final int[] ADDRESSES_6D = new int[]{
        1, 2, 3, 4, 5,
        6, 7, 8, 9, 10,
        21, 22, 23, 24, 25,
        26, 27, 28, 29, 30,
        11, 12, 13, 14, 15,        
        16, 17, 18, 19, 20,
    };
    
    static final double[] ANGLES_NORMAL = new double[]{
        0.00, 0.00, 330.00, 340.89, 319.11,    
        300.00, 300.00, 270.00, 280.89, 259.11,
        240.00, 240.00, 210.00, 220.89, 199.11,
        180.00, 180.00, 150.00, 160.89, 139.11,
        120.00, 120.00,  90.00, 100.89, 79.11,    
        60.00, 60.00, 30.00,  40.89, 19.11
    };

    static final double[] ANGLES_SF = new double[]{
        0.00, 0.00, 19.11, 40.89, 30.00,
        60.00, 60.00, 79.11, 100.89, 90.00, 
        120.00, 120.00, 139.11, 160.89, 150.00, 
        180.00, 180.00, 199.11, 220.89, 210.00,
        240.00, 240.00, 259.11, 280.89, 270.00,
        300.00, 300.00, 319.11, 340.89, 330.00
    }; 
    
    static final double[] ANGLES_6D = new double[]{
        180.00, 180.00, 150.00, 160.89, 139.11,
        120.00, 120.00,  90.00, 100.89, 79.11,    
        60.00, 60.00, 30.00,  40.89, 19.11,
        0.00, 0.00, 330.00, 340.89, 319.11,    
        300.00, 300.00, 270.00, 280.89, 259.11,
        240.00, 240.00, 210.00, 220.89, 199.11,
    };
    
    static final double[] ANGLES_RT = new double[]{
        0.00, 0.00, 0.00, 0.00, 0.00, 0.00
    };    
    
    static final Character[] SEGMENTS = (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.normal) ?  SEGMENTS_NORMAL : ( 
                (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.sf) ? SEGMENTS_SF : (
                        (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt) ? SEGMENTS_RT : SEGMENTS_NORMAL
                )
            );
   
    static final int[] NUMBERS =  (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.normal) ?  NUMBERS_NORMAL : ( 
                (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.sf) ? NUMBERS_SF : 
                ((MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt) ? NUMBERS_RT  : NUMBERS_NORMAL)
            );
            
  
    static final int[] ADDRESSES =(MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.normal) ?  ADDRESSES_NORMAL : ( 
                (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.sf) ? ADDRESSES_SF : ADDRESSES_6D
            );

    
    static final double[] ANGLES = (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.normal) ?  ANGLES_NORMAL : ( 
                (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.sf) ? ANGLES_SF : 
                ((MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt) ? ANGLES_RT : ANGLES_NORMAL)
            );

    final static PointDouble referencePosition = new PointDouble(0.0, -66.9 - 0.2);
    final static Double referenceSize = 6.2 + 0.2;
    final static PointDouble ledUnipuckPosition = new PointDouble(0.0, 0.0);
    final static PointDouble ledMinispinePosition = new PointDouble(0.0, -36.0);
    final static Double unipuckLedSize = 10.0;
    final static Double minispineLedSize = 8.0;
    
    
    PuckType puckType = PuckType.Unknown;
    
    public PuckType getPuckType(){
        if (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt){
            return PuckType.RT;
        }
                
        return puckType;
    }
   
    public void setPuckType(PuckType value){
        puckType = value;
    }
    
    public enum PuckType{
        Empty,
        Minispine,
        Unipuck,
        RT,
        Error,
        Unknown;
        
        public boolean isDefined(){
            return (this==Minispine) || (this==Unipuck)|| (this==RT);
        } 
        
    }
    
    public String getStatus(){
        Detection detection = getDetection();
        PuckType puckType = getPuckType();
        if ((detection==Detection.Present) && puckType.isDefined()) {
            return puckType.toString();
        }
        return detection.toString();
    }
    
    
    public static  boolean displayDetectionError;
    public static void setDisplayDetectionError(boolean value){
        displayDetectionError = value;
    }
            
    public static boolean getDisplayDetectionError(){
        return displayDetectionError;
    }
    
    public double getAngle() {
        return ANGLES[index];
    }

    final int numberOfSamples = samplesPosition.length;

    final int index;

    Character segment;
    final int address;
    final int number;
    final double angle;
    
    public static enum PuckDetectionMode{
       Inductive,
       Mechanical,
       Both
    }
    
    public static class PuckConfig extends DeviceConfig{
        public boolean disabled;
        public PuckDetectionMode detection = PuckDetectionMode.Both;  
    }

    Puck(BasePlate basePlate, int index) {
        //super(String.valueOf(index+1));
        super(SEGMENTS[index] + "" + NUMBERS[index], new PuckConfig());
        this.setParent(basePlate);
        this.index = index;
        this.segment = SEGMENTS[index];
        this.number = NUMBERS[index];
        this.address = ADDRESSES[index];
        this.angle = getAngle();
        for (int i = 0; i < numberOfSamples; i++) {
            new Sample(this, i);
        }
    }
    
    Puck(BasePlate basePlate, int index, Character segment, int number, int address, int angle) {
        //super(String.valueOf(index+1));
        super(segment + "" + number, new PuckConfig());
        this.setParent(basePlate);
        this.index = index;
        this.segment = segment;
        this.number = number;
        this.address = address;
        this.angle = angle;
        for (int i = 0; i < numberOfSamples; i++) {
            new Sample(this, i);
        }
    }
    

    @Override
    public PuckConfig getConfig(){
        return (PuckConfig) super.getConfig();
    }
    
    public boolean isDisabled(){
        return getConfig().disabled;
    }

    public PuckDetectionMode getDetectionMode(){
        return getConfig().detection == null ? PuckDetectionMode.Both: getConfig().detection;
    }
    
    public BasePlate getBasePlate() {
        return (BasePlate) getParent();
    }

    DimensionDouble getSize() {
        return new DimensionDouble(67.0, 67.0);
    }

    public Sample[] getSamples() {
        ArrayList<Sample> ret = new ArrayList<>();
        for (Device d : getChildren()) {
            ret.add((Sample) d);
        }
        return ret.toArray(new Sample[0]);
    }

    
    public int getIndex() {
        return index;
    }
    String id;

    public String getId() {
        //return "XXX000" + index;
        return id;
    }

    public void setId(String value) {
        for (Device d : getParent().getChildren()) {
            if (d instanceof Puck) {
                if (((Puck)d).getId() != null){
                    if (((Puck)d).getId().equals(value)){
                        ((Puck)d).setId(null);
                    }
                }
            }
        }        
        id = value;
    }

    public char getSegment() {
        return segment;
    }

    public int getNumber() {
        return number;
    }

    public int getAddress() {
        return address;
    }
    
    public int getUserIndex(){
         return (getSegment() - new Character('A')) * BasePlate.numberOfPucksPerSegments + getNumber() - 1;
    }

    boolean enabled;

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean value) {
        enabled = value;
    }

    public enum Detection {
        Empty,
        Present,
        Offline,
        Error
    }

    Detection detection = Detection.Error;

    public Detection getDetection() {
        if (MainPanel.BASE_PLATE_LAYOUT == MainPanel.BasePlateLayout.rt){
            return Detection.Present;
        }
        return detection;
    }

    boolean detectionError;

    public boolean isDetectionError() {
        return detectionError;
    }

    private boolean selected;

    public boolean isSelected() {
        return selected;
    }

    public void toggleSelected(boolean value) {
        setSelected(!selected);
    }
    
    public void setSelected(boolean value) {
        if (value != selected) {
            if (value == true) {
                for (Device d : getParent().getChildren()) {
                    if (d instanceof Puck) {
                        ((Puck) d).selected = false;
                        for (Sample sample : ((Puck) d).getSamples()) {
                            sample.selected = false;
                        }                        
                    }
                }
            }
            for (Sample sample : getSamples()) {
                sample.selected = false;
            }
            selected = value;
            getBasePlate().onSelectionChanged();
        }
    }

    public int getNumberOfSamples() {
        return numberOfSamples;
    }
    
}