package org.openslx.util.vm;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.TreeMap;

import org.apache.log4j.Logger;
import org.openslx.bwlp.thrift.iface.OperatingSystem;
import org.openslx.bwlp.thrift.iface.Virtualizer;
import org.openslx.thrifthelper.TConst;
import static org.openslx.util.vm.QemuConfig.Header.*;

class QemuDDAccelMeta {

    public final boolean isPresent;

    public QemuDDAccelMeta(boolean present) {
        isPresent = present;
    }
}

class QemuHWVersionMeta {

    public final int version;

    public QemuHWVersionMeta(int vers) {
        version = vers;
    }
}

class QemuEthernetDevTypeMeta {

    public final String value;

    public QemuEthernetDevTypeMeta(String val) {
        value = val;
    }
}

class QemuSoundCardMeta {

    public final boolean isPresent;
    public final String value;

    public QemuSoundCardMeta(boolean present, String val) {

        isPresent = present;
        value = val;
    }
}
class QemuUSBMeta {

    public final String value;
    public final int speed;

    public QemuUSBMeta(String value, int speed) {

        this.value = value;
        this.speed = speed;
    }
}

public final class QemuMetaData extends VmMetaData<QemuSoundCardMeta, QemuDDAccelMeta, QemuHWVersionMeta, QemuEthernetDevTypeMeta, QemuUSBMeta> {

    private static final Logger LOGGER = Logger.getLogger(QemuMetaData.class);

    private static final Virtualizer virtualizer = new Virtualizer(TConst.VIRT_QEMU, "QEMU-KVM");

    private final QemuConfig config;

    private TreeMap<String, String> option;

    private LinkedHashMap<String, String> header;

    private int cdromCounter = 0;

    private int floppyCounter = 0;

    private int netdevCounter = 0;

    public static enum EthernetType {
        NAT("qnet1"), BRIDGED("qnet0"), HOST_ONLY("qnet2");

        public final String vmnet;

        private EthernetType(String vnet) {
            this.vmnet = vnet;
        }
    }

    public QemuMetaData(List<OperatingSystem> osList, File config) {
        super(osList);
        this.config = new QemuConfig(config);
        init();
    }

    public QemuMetaData(List<OperatingSystem> osList, byte[] vmContent, int length) throws IOException, UnsupportedVirtualizerFormatException {
        super(osList);
        this.config = new QemuConfig(vmContent, length);
        init();
    }

    public void init() {
        registerVirtualHW();
        config.setHdds();
        displayName = config.getDisplayName();
        setOs(config.getOsName());
        isMachineSnapshot = config.isMachineSnapshot();
        for (HardDisk hardDisk : config.getHdds()) {
            hdds.add(hardDisk);
        }
    }

    @Override
    public byte[] getFilteredDefinitionArray() {
        //TODO: Filter is done fix server side
        return config.toString(false).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public byte[] getDefinitionArray() {
        return config.toString(true).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public void applySettingsForLocalEdit() {
        //nothing ! for VMware
    }

    @Override
    public boolean addHddTemplate(File diskImage, String hddMode, String redoDir) {
        return addHddTemplate(diskImage.getName(), hddMode, redoDir);
    }

    @Override
    public boolean addHddTemplate(String diskImagePath, String hddMode, String redoDir) {
        DriveBusType bus = null;
        option = new TreeMap<>();
        option = config.get(DRIVE.getHeader(), DRIVE.getID());

        if (option != null) {
            option.remove("file");
            option.put("file", diskImagePath);
            if (option.get("if") == null) {

            } else {
                switch (option.get("if")) {
                    case "ide":
                        bus = DriveBusType.IDE;
                        break;
                    case "scsi":
                        bus = DriveBusType.SCSI;
                        break;
                    case "sata":
                        //not available for Qemu. Others : sd, mtd, floppy, pflash, virtio
                        break;
                    default:
                        break;
                }
            }
        } else {
            LOGGER.error("Missing disk");
        }
        header = new LinkedHashMap<>();
        header.put(DRIVE.getHeader(), DRIVE.getID());
        config.set(header, option);

        option = new TreeMap<>();
        option = config.get(DEVICE.getHeader(), DEVICE.getID());

        if (option == null) {
            option = new TreeMap<>();
            header = new LinkedHashMap<>();
            header.put(DEVICE.getHeader(), null);

            option.put("drive", DRIVE.getID());
            if (bus != null) {
                if (bus.equals(DriveBusType.IDE)) {
                    option.put("driver", "ide-hd");
                } else if (bus.equals(DriveBusType.SCSI)) {
                    option.put("driver", "scsi-hd");
                }
            } else {
                //Shouldn't come to this but to check TODO
            }
            config.set(header, option);
        }
        return true;
    }

    @Override
    public boolean addDefaultNat() {
        //No arguments needed, default on nat. But cannot receive
        return true;
    }

    @Override
    public void setOs(String vendorOsId) {
        setOs(TConst.VIRT_QEMU, vendorOsId);
    }

    @Override
    public boolean addDisplayName(String name) {
        option = new TreeMap<>();
        option.put("guest", name);

        header = new LinkedHashMap<>();
        header.put(NAME.getHeader(), null);

        config.set(header, option);
        return true;
    }

    @Override
    public boolean addRam(int mem) {
        option = new TreeMap<>();
        option.put("size", "" + mem);

        header = new LinkedHashMap<>();
        header.put(MEMORY.getHeader(), null);

        config.set(header, option);
        return true;
    }

    @Override
    public void addFloppy(int index, String image, boolean readOnly) {
        option = new TreeMap<>();
        if (readOnly) {
            option.put("readonly", "on");
        } else {
            option.put("readonly", "off");
        }
        option.put("if", "floppy");
        option.put("file", image);

        header = new LinkedHashMap<>();
        header.put(DRIVE.getHeader(), "floppy" + floppyCounter);
        config.set(header, option);
        floppyCounter++;
    }

    @Override
    public boolean addCdrom(String image) {
        option = new TreeMap<>();
        option.put("media", "cdrom");
        option.put("file", image);
        header = new LinkedHashMap<>();
        header.put(DRIVE.getHeader(), "cdrom" + cdromCounter);
        config.set(header, option);
        cdromCounter++;
        return true;
    }

    @Override
    public boolean addCpuCoreCount(int nrOfCores) {
        option = new TreeMap<>();
        option.put("cpus", nrOfCores + "");

        header = new LinkedHashMap<>();
        header.put(SMP.getHeader(), null);
        config.set(header, option);
        return true;
    }

    @Override
    public void setSoundCard(VmMetaData.SoundCardType type) {
        //TODO Not possible will be set as comment in config file
    }

    @Override
    public VmMetaData.SoundCardType getSoundCard() {
        //TODO set to default, just write comment
        return VmMetaData.SoundCardType.DEFAULT;
    }

    @Override
    public void setDDAcceleration(VmMetaData.DDAcceleration type) {
        //TODO: Not really used by qemu. 
    }

    @Override
    public VmMetaData.DDAcceleration getDDAcceleration() {
        return DDAcceleration.OFF;
    }

    @Override
    public void setHWVersion(VmMetaData.HWVersion type) {
        //nothing...
    }

    @Override
    public VmMetaData.HWVersion getHWVersion() {
        return VmMetaData.HWVersion.DEFAULT;
    }

    @Override
    public void setEthernetDevType(int cardIndex, VmMetaData.EthernetDevType type) {
				/*
        //TODO
        QemuEthernetDevTypeMeta dev = networkCards.get(type);
        header = new LinkedHashMap<>();
        header.put(DEVICE.getHeader(), "net" + netdevCounter);
        option = new TreeMap<>();
        option.put("driver",  dev.value);
        //option.put("netdev", "net" + cardIndex);
        config.set(header, option);
        netdevCounter++;
				*/
    }

    @Override
    public VmMetaData.EthernetDevType getEthernetDevType(int cardIndex) {
        //TO DO
        return EthernetDevType.AUTO;
    }

    @Override
    public boolean addEthernet(VmMetaData.EtherType type) {
        boolean ret = false;
        int index = 0;
        //TODO use existing interface if given or create a new one
        for (;; ++index) {
            DEVICE.setID("netType" + index);
            TreeMap<String, String> dev = config.get(DEVICE.getHeader(), DEVICE.getID());

            if (dev == null || dev.get("netdev") == null) {
                break;
            }
            
        }

        switch (type) {
            case NAT:
                ret = addEthernet(index, EthernetType.NAT);
                break;
            case BRIDGED:
                ret = addEthernet(index, EthernetType.BRIDGED);
                break;
            case HOST_ONLY:
                ret = addEthernet(index, EthernetType.HOST_ONLY);
                break;
            default:
                // Should not come to this...
                break;
        }
        return ret;
    }

    public boolean addEthernet(int index, EthernetType type) {
        NETDEV.setID("net" + index);
        header = new LinkedHashMap<>();
        header.put(NETDEV.getHeader(), NETDEV.getID());
        //netdev
        option = new TreeMap<>();
        //device tap,ifname=nat1
        option.put("ifname", type.vmnet);
        option.put("type", "tap");
        config.set(header, option);
        //device
        header = new LinkedHashMap<>();
        header.put(DEVICE.getHeader(), "netType" + netdevCounter);
        option = new TreeMap<>();
        option.put("driver", "e1000");
        option.put("netdev", NETDEV.getID());
        config.set(header, option);
        netdevCounter++;
        return true;
    }

    @Override
    public Virtualizer getVirtualizer() {
        return virtualizer;
    }

//    @Override
//    public void enableUsb(boolean enabled) {
//        option = new TreeMap<>();
//        if (enabled) {
//            option.put("usb", "on");
//        } else {
//            option.put("usb", "off");
//        }
//
//        header = new LinkedHashMap<>();
//        header.put(MACHINE.getHeader(), MACHINE.getID());
//        config.set(header, option);
//    }

//    @Override
//   public boolean disableSuspend() {
//        return false;
//    }
		@Override
		public boolean tweakForNonPersistent() {
			return false;
		}
	public void setMaxUsbSpeed( VmMetaData.UsbSpeed speed )
	{
		// TODO: Actual speed setting?
		if ( speed == null || speed == VmMetaData.UsbSpeed.NONE ) {
			option.remove( "usb" );
		} else {
			option.put( "usb", "" );
		}
	}

	@Override
	public VmMetaData.UsbSpeed getMaxUsbSpeed()
	{
		if (option.containsKey( "usb" ) )
			return VmMetaData.UsbSpeed.USB2_0; // TODO
		return VmMetaData.UsbSpeed.NONE;
	}
    @Override
    public void registerVirtualHW() {
        soundCards.put(VmMetaData.SoundCardType.NONE, new QemuSoundCardMeta(false, null));
        soundCards.put(VmMetaData.SoundCardType.DEFAULT, new QemuSoundCardMeta(true, "ich6"));
        soundCards.put(VmMetaData.SoundCardType.AC, new QemuSoundCardMeta(true, "ac97"));
        soundCards.put(VmMetaData.SoundCardType.ES, new QemuSoundCardMeta(true, "es1370"));
        soundCards.put(VmMetaData.SoundCardType.SOUND_BLASTER, new QemuSoundCardMeta(true, "sb16"));

        ddacc.put(VmMetaData.DDAcceleration.OFF, new QemuDDAccelMeta(false));
        ddacc.put(VmMetaData.DDAcceleration.ON, new QemuDDAccelMeta(true));

        hwversion.put(VmMetaData.HWVersion.DEFAULT, new QemuHWVersionMeta(0));

				usbSpeeds.put(VmMetaData.UsbSpeed.NONE, new QemuUSBMeta(null, 0));
				usbSpeeds.put(VmMetaData.UsbSpeed.USB1_1, new QemuUSBMeta("usb", 1));
				usbSpeeds.put(VmMetaData.UsbSpeed.USB2_0, new QemuUSBMeta("ehci", 2));
				usbSpeeds.put(VmMetaData.UsbSpeed.USB3_0, new QemuUSBMeta("usb_xhci", 3));

        //networkCards.put(VmMetaData.EthernetDevType.VIRTIO, new QemuEthernetDevTypeMeta("virtio-net-pci"));
        networkCards.put(VmMetaData.EthernetDevType.E1000, new QemuEthernetDevTypeMeta("e1000"));
        networkCards.put(VmMetaData.EthernetDevType.PCNET32, new QemuEthernetDevTypeMeta("pcnet"));
        //networkCards.put(VmMetaData.EthernetDevType.RTL8139, new QemuEthernetDevTypeMeta("rtl8139"));

    }
}