import { createCommands, logger } from '@jolibox/common';
import { createAPI, registerCanIUse, t } from './base';
import { taskTracker } from '../report';

enum ECrossFrameEvent {
  JOLIBOX_GAME_TASK_LEVEL_FINISHED = 'JOLIBOX_GAME_TASK_LEVEL_FINISHED',
  JOLIBOX_GAME_TASK_GAME_PLAY_ENDED = 'JOLIBOX_GAME_TASK_GAME_PLAY_ENDED',
  JOLIBOX_GAME_TASK_LEVEL_UPGRADE = 'JOLIBOX_GAME_TASK_LEVEL_UPGRADE',
  JOLIBOX_GAME_TASK_LEVEL_START = 'JOLIBOX_GAME_TASK_LEVEL_START',
  JOLIBOX_GAME_TASK_LEVEL_FAILED = 'JOLIBOX_GAME_TASK_LEVEL_FAILED'
}

const notifyIframeGameTaskEvent = (eventName: string, data: any) => {
  const parentWindow = window.parent;
  if (parentWindow && parentWindow !== window && typeof parentWindow.postMessage === 'function') {
    parentWindow.postMessage(
      {
        type: eventName,
        data
      },
      '*'
    );
  }
};

const commands = createCommands();

const onLevelFinished = createAPI('levelFinished', {
  paramsSchema: t.tuple(
    t.object({
      levelId: t.or(t.string(), t.number()),
      duration: t.number().optional(),
      rating: t.number().optional(),
      score: t.number().optional(),
      variation: t.string().optional()
    })
  ),
  implement: async (parmas) => {
    const { levelId, duration, rating, score, variation } = parmas;
    logger.info(`onLevelFinished`, duration, rating, score, variation);
    notifyIframeGameTaskEvent(ECrossFrameEvent.JOLIBOX_GAME_TASK_LEVEL_FINISHED, {
      levelId,
      duration,
      rating,
      score,
      variation
    });
    await Promise.all([
      taskTracker.reporter({
        event: 'COMPLETE_GAME_LEVEL',
        extraParams: {
          inGameInfo: {
            levelId,
            duration,
            rating,
            score
          }
        }
      }),
      taskTracker.tracker('LevelFinished', {
        levelId,
        duration,
        rating,
        score,
        variation
      })
    ]);
  }
});

const onGamePlayEnded = createAPI('gamePlayEnded', {
  paramsSchema: t.tuple(
    t.object({
      duration: t.number().optional(),
      rating: t.number().optional(),
      score: t.number(),
      variation: t.string().optional()
    })
  ),
  implement: async (params) => {
    const { duration, rating, score, variation } = params;
    logger.info(`onGamePlayEnded`, duration, rating, score, variation);
    notifyIframeGameTaskEvent(ECrossFrameEvent.JOLIBOX_GAME_TASK_GAME_PLAY_ENDED, {
      duration,
      rating,
      score,
      variation
    });
    await Promise.all([
      taskTracker.tracker('GamePlayEnded', {
        duration,
        rating,
        score,
        variation
      }),
      taskTracker.reporter({
        event: 'GAME_ENDED',
        extraParams: {
          inGameInfo: {
            duration,
            rating,
            score
          }
        }
      })
    ]);
  }
});

const onLevelUpgrade = createAPI('levelUpgrade', {
  paramsSchema: t.tuple(
    t.object({
      levelId: t.or(t.string(), t.number()),
      name: t.string().optional()
    })
  ),
  implement: async ({ levelId, name }) => {
    logger.info(`onLevelUpgrade`, levelId, name);
    notifyIframeGameTaskEvent(ECrossFrameEvent.JOLIBOX_GAME_TASK_LEVEL_UPGRADE, {
      levelId,
      name
    });
    await Promise.all([
      taskTracker.tracker('LevelUpgrade', {
        name,
        levelId
      }),
      taskTracker.reporter({
        event: 'GAME_LEVEL_UP',
        extraParams: {
          inGameInfo: {
            levelId,
            levelName: name
          }
        }
      })
    ]);
  }
});

const onLevelStart = createAPI('levelStart', {
  paramsSchema: t.tuple(
    t.object({
      levelId: t.or(t.string(), t.number())
    })
  ),
  implement: async (params) => {
    const { levelId } = params;
    logger.info(`onLevelStart`, levelId);

    notifyIframeGameTaskEvent(ECrossFrameEvent.JOLIBOX_GAME_TASK_LEVEL_START, {
      levelId
    });

    await taskTracker.tracker('LevelStart', {
      levelId
    });
  }
});

const onLevelFailed = createAPI('levelFailed', {
  paramsSchema: t.tuple(
    t.object({
      levelId: t.or(t.string(), t.number()),
      score: t.number().optional(),
      rating: t.number().optional(),
      duration: t.number().optional()
    })
  ),
  implement: async (params) => {
    const { levelId, score, rating, duration } = params;
    logger.info(`onLevelFailed`, levelId, score, rating, duration);

    notifyIframeGameTaskEvent(ECrossFrameEvent.JOLIBOX_GAME_TASK_LEVEL_FAILED, {
      levelId,
      score,
      rating,
      duration
    });

    await taskTracker.tracker('LevelFailed', {
      levelId,
      score,
      rating,
      duration
    });
  }
});

commands.registerCommand('TaskTrackerSDK.levelFinished', onLevelFinished);
commands.registerCommand('TaskTrackerSDK.gamePlayEnded', onGamePlayEnded);
commands.registerCommand('TaskTrackerSDK.levelUpgrade', onLevelUpgrade);
commands.registerCommand('TaskTrackerSDK.levelStart', onLevelStart);
commands.registerCommand('TaskTrackerSDK.levelFailed', onLevelFailed);

registerCanIUse('TaskTrackerSDK.onLevelFinished', {
  version: '1.1.25',
  properties: {
    params: {
      levelId: '1.1.25',
      duration: '1.1.25',
      rating: '1.1.25',
      score: '1.1.25',
      variation: '1.1.50'
    }
  }
});

registerCanIUse('TaskTrackerSDK.onGamePlayEnded', {
  version: '1.1.25',
  properties: {
    params: {
      duration: '1.1.25',
      rating: '1.1.25',
      score: '1.1.25',
      variation: '1.1.50'
    }
  }
});

registerCanIUse('TaskTrackerSDK.onLevelUpgrade', {
  version: '1.1.25',
  properties: {
    params: {
      levelId: '1.1.25',
      name: '1.1.25'
    }
  }
});

registerCanIUse('TaskTrackerSDK.onLevelStart', {
  version: '1.3.8',
  properties: {
    params: {
      levelId: '1.3.8'
    }
  }
});

registerCanIUse('TaskTrackerSDK.onLevelFailed', {
  version: '1.3.8',
  properties: {
    params: {
      levelId: '1.3.8',
      score: '1.3.8',
      rating: '1.3.8',
      duration: '1.3.8'
    }
  }
});