module.exports = (env) ->

  deviceConfigDef = require("./device-config-schema");

  random = require('random-number').generator({
    min:  1000000,
    max:  9999999,
    integer: true
  });

  WebSocket = require('ws');
  UUID = require('uuid');
  Rx = require('rxjs');

  class Homematic extends env.plugins.Plugin

    constructor: ->
      @homegearId = UUID.v4();

    sendRequest: (request) =>

      request.id = request.id || random();
      request.jsonrpc = "2.0";

      env.logger.debug("Sending Request: #{JSON.stringify(request)}");

      @serverSocket.next(JSON.stringify(request));
      return @serverSocket.filter((response) =>
        return response.id == request.id;
      ).map((response) =>
        env.logger.debug("Received Response: #{JSON.stringify(response)}");
        return response;
      ).first();

    onNotification: (peerId) =>

      return @serverSocket.filter((message) ->
        return message.id == undefined
      );

    subscribePeer: (peerId) =>
      return @sendRequest({
        method: "subscribePeers",
        params:[@homegearId, [peerId]]
      });

    init: (app, @framework, @config) =>

      ###@framework.deviceManager.registerDeviceClass("HomematicHeatingThermostat", {
        configDef: deviceConfigDef.HomematicHeatingThermostat,
        createCallback: (config, lastState) -> new HomematicHeatingThermostat(config, lastState)
      })###

      @serverSocket = Rx.Observable.webSocket({
        url: "ws://#{@config.host}:#{@config.port}/#{@homegearId}",
        WebSocketCtor: WebSocket,
        protocol: 'server',
        openObserver:
          next: (e) =>
            env.logger.info("Connected to homegear system [#{@homegearId}]. #{e.target.protocol}")
      });

      @clientSocket = Rx.Observable.webSocket({
        url: "ws://#{@config.host}:#{@config.port}/#{@homegearId}",
        openObserver: @openObserver,
        WebSocketCtor: WebSocket,
        protocol: 'client',
        openObserver:
          next: (e) =>
            env.logger.info("Connected to homegear system [#{@homegearId}]. #{e.target.protocol}");
      });

      @serverSocket.subscribe((message) =>
        env.logger.debug("MESSAGE (Server): #{JSON.stringify(message)}")
      );

      @clientSocket.subscribe((message) =>
        env.logger.debug("MESSAGE (Client): #{JSON.stringify(message)}")
      );

      @framework.deviceManager.registerDeviceClass("HomematicSwitch", {
        configDef: deviceConfigDef.HomematicSwitch,
        createCallback: (config, lastState) => new HomematicSwitch(config, lastState)
      })

      @framework.deviceManager.registerDeviceClass("HomematicPowerSwitch", {
        configDef: deviceConfigDef.HomematicPowerSwitch,
        createCallback: (config, lastState) => new HomematicPowerSwitch(config, lastState)
      })

  homegear = new Homematic

  class HomematicSwitch extends env.devices.PowerSwitch

    constructor: (@config, @lastState) ->
      @name = @config.name;
      @id = @config.id;
      super();

      env.logger.debug('LastState:', @lastState);
      @_state = @lastState;

      homegear.subscribePeer(@config.peerId).subscribe((response) =>
        env.logger.debug("Peer subscribed to homegear. [Server] #{@config.peerId}");
      );

      homegear.onNotification(@config.peerId).subscribe((notification) =>
        env.logger.debug("Received Notification for #{@config.peerId}: #{JSON.stringify(notification)}");
      );

    destroy: () =>
      super();

    getState: =>
      if @_state? then return Rx.Observable.of(@_state).toPromise();
      return homegear.sendRequest({
        method: 'getValue',
        params: [@config.peerId, 1, "STATE"]
      }).map((response) =>
        return @_state = response.result;
      ).toPromise();

    changeStateTo: (state) =>
      if @_state is state then return Rx.Observable.of(@_state).toPromise();
      return homegear.sendRequest({
        method: 'setValue',
        params: [@config.peerId, 1, "STATE", state]
      }).map((response) =>
        @emit("state", @_state = state);
        return @_state;
      ).toPromise();

  class HomematicPowerSwitch extends HomematicSwitch

    constructor: (@config, @lastState) ->
      super(@config, @lastState);

    destroy: () =>
      super();

  return homegear;