package de.tudarmstadt.informatik.hostage.protocol.cifs;

import android.content.Context;
import android.net.DhcpInfo;
import android.net.wifi.WifiManager;

import org.alfresco.jlan.app.JLANCifsServer;
import org.alfresco.jlan.app.XMLServerConfiguration;
import org.alfresco.jlan.netbios.NetworkSettings;
import org.alfresco.jlan.server.NetworkServer;
import org.alfresco.jlan.server.ServerListener;
import org.alfresco.jlan.server.SessionListener;
import org.alfresco.jlan.server.SrvSession;
import org.alfresco.jlan.server.filesys.DiskDeviceContext;
import org.alfresco.jlan.server.filesys.DiskInterface;
import org.alfresco.jlan.server.filesys.DiskSharedDevice;
import org.alfresco.jlan.server.filesys.FileListener;
import org.alfresco.jlan.server.filesys.FilesystemsConfigSection;
import org.alfresco.jlan.server.filesys.NetworkFile;
import org.alfresco.jlan.server.filesys.NetworkFileServer;
import org.alfresco.jlan.server.filesys.SrvDiskInfo;
import org.alfresco.jlan.smb.server.CIFSConfigSection;
import org.springframework.extensions.config.element.GenericConfigElement;

import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;

import de.tudarmstadt.informatik.hostage.Handler;
import de.tudarmstadt.informatik.hostage.R;
import de.tudarmstadt.informatik.hostage.logging.MessageRecord;
import de.tudarmstadt.informatik.hostage.protocol.CIFS;
import de.tudarmstadt.informatik.hostage.ui.activity.MainActivity;

/**
 * HostageV3
 * ================

 * Created by abrakowski on 19.03.15.
 */
public class CifsServer extends JLANCifsServer {

    private final XMLServerConfiguration serverConfiguration;
    protected final CIFS cifs;

    public CifsServer(XMLServerConfiguration serverConfiguration, CIFS cifs){
        super();

        this.cifs = cifs;
        this.serverConfiguration = serverConfiguration;
    }

    public void run() throws Exception {
        CIFSConfigSection cifsConfigSection = (CIFSConfigSection) serverConfiguration.getConfigSection(CIFSConfigSection.SectionName);
        cifsConfigSection.setBroadcastMask(getBroadcastAddress());
        cifsConfigSection.setHostAnnouncer(true);
        cifsConfigSection.setDisableNIOCode(true);

        int ip = cifs.getLocalIp();

        cifsConfigSection.setSMBBindAddress(intToInetAddress(ip));
        cifsConfigSection.setNetBIOSBindAddress(intToInetAddress(ip));
        NetworkSettings.setBroadcastMask(getBroadcastAddress());

        if(cifsConfigSection.hasNetBIOSSMB()){
            serverConfiguration.addServer(createNetBIOSServer(serverConfiguration));
        }

        serverConfiguration.addServer(createSMBServer(serverConfiguration));

        FilesystemsConfigSection filesysConfig = (FilesystemsConfigSection) serverConfiguration.getConfigSection(FilesystemsConfigSection.SectionName);

        File cacheFolder = MainActivity.context.getExternalCacheDir();
        File jlanFolder = new File(cacheFolder.getAbsolutePath() + "/jlan");

        File anotherFolder = new File(jlanFolder.getAbsolutePath() + "/Windows");
        File progData = new File(jlanFolder.getAbsolutePath() + "/ProgramData");
        File users = new File(jlanFolder.getAbsolutePath() + "/Users");
        File temp= new File(jlanFolder.getAbsolutePath() + "/temp");
        jlanFolder.mkdir();
        anotherFolder.mkdir();
        progData.mkdir();
        users.mkdir();
        temp.mkdir();

        // SHARES
        DiskInterface diskInterface = new PseudoJavaFileDiskDriver(cifs);
        final GenericConfigElement driverConfig = new GenericConfigElement("driver");
        final GenericConfigElement localPathConfig = new GenericConfigElement("LocalPath");
        localPathConfig.setValue(jlanFolder.getAbsolutePath());
        driverConfig.addChild(localPathConfig);
        DiskDeviceContext diskDeviceContext = (DiskDeviceContext) diskInterface.createContext("JLANSHARE", driverConfig);
        diskDeviceContext.setShareName("JLANSHARE");
        diskDeviceContext.setConfigurationParameters(driverConfig);
        diskDeviceContext.enableChangeHandler(false);
        diskDeviceContext.setDiskInformation(new SrvDiskInfo(2560000, 64, 512, 2304000));// Default to a 80Gb sized disk with 90% free space
        DiskSharedDevice diskDev = new DiskSharedDevice("JLANSHARE", diskInterface, diskDeviceContext);
        diskDev.setConfiguration(serverConfiguration);
        diskDeviceContext.startFilesystem(diskDev);
        filesysConfig.addShare(diskDev);

        for(int i=0; i<serverConfiguration.numberOfServers(); i++){
            NetworkServer server = serverConfiguration.getServer(i);

            if(server instanceof NetworkFileServer){
                NetworkFileServer fileServer = (NetworkFileServer) server;
                fileServer.addFileListener(new FileListener() {
                    @Override
                    public void fileClosed(SrvSession sess, NetworkFile file) {
                    }

                    @Override
                    public void fileOpened(SrvSession sess, NetworkFile file) {
                    }
                });
            }

            server.addServerListener(new ServerListener() {
                @Override
                public void serverStatusEvent(NetworkServer server, int event) {
                }
            });

            server.addSessionListener(new SessionListener() {
                @Override
                public void sessionClosed(SrvSession sess) {


                    cifs.log(MessageRecord.TYPE.RECEIVE, "SESSION CLOSED", 139, sess.getRemoteAddress(), 139);
                }

                @Override
                public void sessionCreated(SrvSession sess) {
                    cifs.getListener().getService().notifyUI(Handler.class.getName(),
                            new String[] {
                                    cifs.getListener().getService().getString(R.string.broadcast_started),
                                    cifs.getListener().getProtocol().toString(),
                                    Integer.toString(cifs.getListener().getPort())
                            }
                    );

                    cifs.log(MessageRecord.TYPE.RECEIVE, "SESSION CREATED", 139, sess.getRemoteAddress(), 139);

                }

                @Override
                public void sessionLoggedOn(SrvSession sess) {

                    cifs.log(MessageRecord.TYPE.RECEIVE, "SESSION LOGGED ON", 139, sess.getRemoteAddress(), 139);

                }
            });
            server.getShareMapper();
            server.startServer();
        }
    }

    public void stop(){
        for(int i=0; i<serverConfiguration.numberOfServers(); i++){
            NetworkServer server = serverConfiguration.getServer(i);
            server.shutdownServer(true);
        }
    }

    private String getBroadcastAddress() throws IOException {
        WifiManager wifi = (WifiManager) MainActivity.context.getSystemService(Context.WIFI_SERVICE);
        DhcpInfo dhcp = wifi.getDhcpInfo();
        // handle null somehow
        System.out.println("DEBUG:::::IP::::"+dhcp.ipAddress);
        int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
        byte[] quads = new byte[4];
        for (int k = 0; k < 4; k++)
            quads[k] = (byte) (broadcast >> (k * 8));
        return InetAddress.getByAddress(quads).toString().substring(1);
    }

    public static InetAddress intToInetAddress(int hostAddress) {
        byte[] addressBytes = { (byte)(0xff & hostAddress),
                (byte)(0xff & (hostAddress >> 8)),
                (byte)(0xff & (hostAddress >> 16)),
                (byte)(0xff & (hostAddress >> 24)) };

        try {
            return InetAddress.getByAddress(addressBytes);
        } catch (UnknownHostException e) {
            throw new AssertionError();
        }
    }
}