// app init

import { diContainer } from "./di/inversify.config";
import { InversifyExpressServer } from "inversify-express-utils";
import { environment } from "./environment/environment";
import { appErrorHandlerMiddleWare, appMiddleWare } from "./api/app";
import { ILogger } from "./service/logger/logger";
import { TYPES } from "./di/di-types";
import { SocketService } from "./service/socket/socket.service";

const logger = diContainer.get<ILogger>(TYPES.Logger);
const socketService = diContainer.get<SocketService>(TYPES.SocketService);

// create server
const server = new InversifyExpressServer(diContainer);
server.setConfig(appMiddleWare);
server.setErrorConfig(appErrorHandlerMiddleWare);

// @ts-ignore
process.on("unhandledRejection", (reason: string, p: Promise<any>) => {
  console.error(reason, "unhandledRejection");
  throw reason;
});

process.on("uncaughtException", (error: Error) => {
  logger.error(error, "uncaughtException");
  process.exit(1);
});

export const app = server.build();
// tslint:disable-next-line:no-var-requires
const io = require("socket.io")(server);
socketService.init(io);
app.listen(environment.port, environment.host, () => {
  logger.log(
    "Node server started on:",
    environment.http_type,
    environment.host,
    environment.port
  );
});

/// SocketService

import * as socketioJwt from "socketio-jwt";
import { IMySocket, ISocketService } from "./socket.interface";
import { inject, injectable } from "inversify";
import { SocketEvents } from "./socket-events";
import { ILogger } from "../logger/logger";
import { TYPES } from "../../di/di-types";
import { environment } from "../../environment/environment";
import { Requester } from "../../shared/requester";
import { InvalidTokenError } from "../../shared/errors/invalid-token.error";
import { AuthenticationService } from "../auth/authentication.service";

@injectable()
export class SocketService implements ISocketService {
  constructor(
    @inject(TYPES.Logger) private logger: ILogger,
    @inject(TYPES.AuthenticationService)
    private authenticationService: AuthenticationService
  ) {}

  public init(io: any) {
    this.logger.log("init socket");
    const self = this;

    io.sockets
      .on(
        "connection",
        socketioJwt.authorize({
          secret: environment.jwtKey,
        })
      )
      .on("authenticated", (socket: IMySocket) => {
        self.logger.log("socket authenticated:");
        for (const currSocket of Object.values(io.sockets.connected)) {
          // чтобы выбрасывало этого же пользователя
          const mySocket: IMySocket = currSocket as IMySocket;

          if (
            mySocket.userId &&
            mySocket.userId === mySocket.decoded_token.id
          ) {
            mySocket.emit(
              SocketEvents.LOGOUT,
              Requester.createError(new InvalidTokenError())
            );

            mySocket.disconnect(true);
          }
        }
        socket.userId = socket.decoded_token.id;
        // Middleware проверка update при каждом запросе.

        socket.use(async (packet, next) => {
          const isValid = await this.authenticationService.isValid(
            socket.decoded_token
          );
          if (isValid) {
            this.logger.log(packet[0]);
            return next();
          } else {
            this.logger.warn(
              "Socket",
              socket.decoded_token.id + " " + socket.decoded_token.name
            );
            io.sockets.connected[socket.id].emit(
              SocketEvents.LOGOUT,
              Requester.createError(new InvalidTokenError())
            );
            next(new Error("socket Ошибка авторизации"));
          }
        });

        socket.on("error", (error) => {
          console.error("error");
        });

        // socket.on(
        //   SocketEvents.MESSAGES,
        //   async (conversationsMessages, callback) => {
        //     try {
        //       const userId = socket.decoded_token.id;
        //       for (const convId of Object.keys(conversationsMessages)) {
        //         const conversationId = parseInt(convId, 10);
        //         const companion = await db_helper.getCompanion(
        //           userId,
        //           conversationId
        //         );
        //         const messages = conversationsMessages[conversationId];
        //         await db_helper.saveMessages(conversationId, userId, messages);
        //         const totalCount = await db_helper.getMessageTotalCount(
        //           conversationId
        //         );
        //         // Отправляем сообщение назад, что мы его получили.
        //         // Отправляем сообщения участнику чата
        //         messages.forEach((msg) => {
        //           msg.totalCount = totalCount;
        //         });
        //         self.sendData(
        //           userId,
        //           companion.user_id,
        //           events.MESSAGES,
        //           messages
        //         );
        //       }
        //
        //       callback(requester.createBody());
        //     } catch (error) {
        //       callback(requester.createError(error));
        //       console.error("Не могу сохранить сообщения пользователя", error);
        //     }
        //   }
        // );
        //
        // socket.on(events.SUPPORT_MESSAGES, async function (messages, callback) {
        //   const user = socket.decoded_token;
        //   const logId = LogContext.getContext(user.id);
        //   const myLogger = new MyLogger(logId, self.constructor.name);
        //   try {
        //     // Проверка что пользователь пишите от себя
        //     myLogger.debug("Try save support message from " + user.id);
        //     const logic = new SaveSupportLogic(logId, user.id, user.role);
        //     const convAndIsCreated = await logic.saveMessagesAndGetConv(
        //       messages
        //     );
        //
        //     if (convAndIsCreated.isCreated) {
        //       self.sendData(
        //         user.id,
        //         convAndIsCreated.supportId,
        //         helpDeskEvents.CONVERSATION,
        //         {
        //           conversation: convAndIsCreated.conversation,
        //           messages: convAndIsCreated.resultMessages,
        //         }
        //       );
        //     } else {
        //       self.sendData(
        //         user.id,
        //         convAndIsCreated.supportId,
        //         helpDeskEvents.MESSAGES,
        //         convAndIsCreated.resultMessages
        //       );
        //     }
        //     // Отправляем сообщение назад, что мы его получили.
        //     callback(requester.createBody(convAndIsCreated.resultMessages));
        //     // Отправляем сообщение пользователю support
        //
        //     // Проверку до отправки?
        //     if (!self.getUserSocket(convAndIsCreated.supportId)) {
        //       for (const message of convAndIsCreated.resultMessages) {
        //         telegramSender.sendSupportNotify(user.id, message.text);
        //       }
        //     }
        //   } catch (error) {
        //     callback(requester.createError(error));
        //     myLogger.myErrorLogger(error);
        //   }
        // });
        //
        // socket.on(
        //   helpDeskEvents.MESSAGES,
        //   async function (dataMessages, callback) {
        //     const user = socket.decoded_token;
        //     const logId = LogContext.getContext(user.id);
        //     const myLogger = new MyLogger(logId, self.constructor.name);
        //     try {
        //       const logic = new HelpDeskMessagesSaveLogic(
        //         logId,
        //         user.id,
        //         myRoles.SERVICE_SUPPORT
        //       );
        //       for (const convId of Object.keys(dataMessages)) {
        //         const messages = dataMessages[convId];
        //         myLogger.debug("try save support message: " + convId);
        //         await logic.saveMessages(convId, messages);
        //         callback(requester.createBody(messages));
        //         const compId = await logic.getCompanion(convId);
        //         if (self.getUserSocket(compId)) {
        //           self.sendData(
        //             user.id,
        //             compId,
        //             events.SUPPORT_MESSAGES,
        //             messages
        //           );
        //         } else {
        //           mailWorker.sendNotifyMessage(user.id, compId, messages);
        //         }
        //
        //         myLogger.debug("message saved: " + convId);
        //       }
        //     } catch (error) {
        //       callback(requester.createError(error));
        //       myLogger.myErrorLogger(error);
        //     }
        //   }
        // );

        // Removing the socket on disconnect
        socket.on("disconnect", () => {
          this.logger.log(null, "disconnect: " + socket.decoded_token.id);
        });
      });
  }

  public getUserSocket(userId: number, {}: {} = {}): object {
    return {};
  }

  public sendData(
    fromId: number | null,
    toId: number,
    event: SocketEvents,
    data: any
  ): void {
    return;
  }
}