/*
 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

const WebSocket = require('ws');
const ts = require('typescript');
const path = require('path');
const fs = require('fs');
const { spawn, execSync } = require('child_process');
const _ = require('lodash');

const { processComponentChild } = require('../lib/process_component_build');
const { createWatchCompilerHost } = require('../lib/ets_checker');
const { writeFileSync } = require('../lib/utils');
const { projectConfig } = require('../main');
const { props } = require('../lib/ets_checker');
const {
  isResource,
  processResourceData,
  isAnimateToOrImmediately,
  processAnimateToOrImmediately
} = require('../lib/process_ui_syntax');
const { dollarCollection } = require('../lib/ets_checker');

const WebSocketServer = WebSocket.Server;

let pluginSocket = '';

let supplement = {
  isAcceleratePreview: false,
  line: 0,
  column: 0,
  fileName: ''
};

const pluginCommandChannelMessageHandlers = {
  'compileComponent': handlePluginCompileComponent,
  'default': () => {}
};
let es2abcFilePath = path.join(__dirname, '../bin/ark/build-win/bin/es2abc');

let previewCacheFilePath;
let previewJsFilePath;
let previewAbcFilePath;
const messages = [];
let start = false;
let checkStatus = false;
let compileStatus = false;
let receivedMsg_;
let errorInfo = [];
let compileWithCheck;
let globalVariable = [];
let propertyVariable = [];
let globalDeclaration = new Map();
let connectNum = 0;
const maxConnectNum = 8;
let codeOverMaxlength = false;

let callback = undefined;

function buildPipeServer() {
  return {
    init(cachePath, buildPath, cb) {
      previewCacheFilePath = path.join(cachePath || buildPath, 'preview.ets');
      const rootFileNames = [];
      writeFileSync(previewCacheFilePath, '');
      rootFileNames.push(previewCacheFilePath);
      ts.createWatchProgram(
        createWatchCompilerHost(rootFileNames, resolveDiagnostic, delayPrintLogCount, ()=>{}, true));
      callback = cb;
    },
    compileComponent(jsonData) {
      handlePluginCompileComponent(jsonData);
    }
  };
}

function init(port) {
  previewCacheFilePath =
    path.join(projectConfig.cachePath || projectConfig.buildPath, 'preview.ets');
  previewJsFilePath =
    path.join(projectConfig.cachePath || projectConfig.buildPath, 'preview.js');
  previewAbcFilePath =
    path.join(projectConfig.cachePath || projectConfig.buildPath, 'preview.abc');
  const rootFileNames = [];
  writeFileSync(previewCacheFilePath, '');
  rootFileNames.push(previewCacheFilePath);
  ts.createWatchProgram(
    createWatchCompilerHost(rootFileNames, resolveDiagnostic, delayPrintLogCount, ()=>{}, true));
  const wss = new WebSocketServer({
    port: port,
    host: '127.0.0.1'
  });
  wss.on('connection', function(ws) {
    if (connectNum < maxConnectNum) {
      connectNum++;
      handlePluginConnect(ws);
    } else {
      ws.terminate();
    }
  });
}

function handlePluginConnect(ws) {
  ws.on('message', function(message) {
    pluginSocket = ws;
    try {
      const jsonData = JSON.parse(message);
      handlePluginCommand(jsonData);
    } catch (e) {
    }
  });
}

function handlePluginCommand(jsonData) {
  pluginCommandChannelMessageHandlers[jsonData.command] ?
    pluginCommandChannelMessageHandlers[jsonData.command](jsonData) :
    pluginCommandChannelMessageHandlers['default'](jsonData);
}

function handlePluginCompileComponent(jsonData) {
  if (jsonData) {
    messages.push(jsonData);
    if (receivedMsg_) {
      return;
    }
  } else if (messages.length > 0) {
    jsonData = messages[0];
  } else {
    return;
  }
  start = true;
  const receivedMsg = _.cloneDeep(jsonData);
  const compilerOptions = ts.readConfigFile(
    path.resolve(__dirname, '../tsconfig.json'), ts.sys.readFile).config.compilerOptions;
  Object.assign(compilerOptions, {
    'sourceMap': false
  });
  const sourceNode = ts.createSourceFile('preview.ets',
    'struct preview{build(){' + receivedMsg.data.script.replace(/new\s+\b(Circle|Ellipse|Rect|Path)\b/g,
      (item, item1) => {
        return 'special' + item1 + 'ForPreview';
      }) + '}}',
    ts.ScriptTarget.Latest, true, ts.ScriptKind.ETS, compilerOptions);
  compileWithCheck = jsonData.data.compileWithCheck || 'true';
  receivedMsg.data.variableScript = '';
  checkPreparation(receivedMsg, sourceNode);
  const previewStatements = [];
  const log = [];
  supplement = {
    isAcceleratePreview: true,
    line: parseInt(JSON.parse(receivedMsg.data.offset).line),
    column: parseInt(JSON.parse(receivedMsg.data.offset).column),
    fileName: receivedMsg.data.filePath || ''
  };
  try {
    processComponentChild(sourceNode.statements[0].members[1].body, previewStatements, log, supplement);
  } catch (e) {
    log.push({
      message: e.stack
    });
  }
  supplement.isAcceleratePreview = false;
  const newSource = ts.factory.updateSourceFile(sourceNode, previewStatements);
  const transformedSourceFile = transformResourceNode(newSource, log);
  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
  const result = printer.printNode(ts.EmitHint.Unspecified, transformedSourceFile, transformedSourceFile);
  receivedMsg.data.script = ts.transpileModule(result, {}).outputText.replace(
    /\bspecial(Circle|Ellipse|Rect|Path)ForPreview\b/g, (item, item1) => {
      return 'new ' + item1;
    });
  receivedMsg.data.log = log;
  if (receivedMsg.data.viewID) {
    receivedMsg.data.script = receivedMsg.data.variableScript + `function quickPreview(context) {
      const fastPreview = function build(){
        ${receivedMsg.data.script}
      }.bind(context);
      fastPreview();
    }
    quickPreview(GetRootView().findChildByIdForPreview(${receivedMsg.data.viewID}))`;
  }
  callEs2abc(receivedMsg);
}

function transformResourceNode(newSource, log) {
  const transformerFactory = (context) => {
    return (rootNode) => {
      function visit(node) {
        node = ts.visitEachChild(node, visit, context);
        return processResourceNode(node, log);
      }
      return ts.visitNode(rootNode, visit);
    };
  };
  const transformationResult = ts.transform(newSource, [transformerFactory]);
  return transformationResult.transformed[0];
}

function processResourceNode(node, log) {
  if (isResource(node)) {
    return processResourceData(node, '', {isAcceleratePreview: true, log: log});
  } else if (isAnimateToOrImmediately(node)) {
    return processAnimateToOrImmediately(node);
  } else {
    return node;
  }
}

function checkPreparation(receivedMsg, sourceNode) {
  let variableScript = '';
  if (previewCacheFilePath && fs.existsSync(previewCacheFilePath) && compileWithCheck === 'true') {
    globalVariable = receivedMsg.data.globalVariable || globalVariable;
    globalVariable = globalVariable.map((item) => {
      globalDeclaration.set(item.identifier, item.declaration);
      return item.identifier;
    });
    for (const [key, value] of sourceNode.identifiers) {
      if (globalVariable.includes(key)) {
        variableScript += globalDeclaration.get(key) + '\n';
      } else if (key.startsWith('$$') && globalVariable.includes(key.substring(2))) {
        variableScript += globalDeclaration.get(key.substring(2)) + '\n';
      }
    }
    propertyVariable = receivedMsg.data.propertyVariable || propertyVariable;
    receivedMsg.data.variableScript = ts.transpileModule(variableScript, {}).outputText;
    writeFileSync(previewCacheFilePath, variableScript + 'struct preview{build(){' + receivedMsg.data.script + '}}');
  }
}

function callEs2abc(receivedMsg) {
  if (fs.existsSync(es2abcFilePath + '.exe') || fs.existsSync(es2abcFilePath)) {
    es2abc(receivedMsg);
  } else {
    es2abcFilePath = path.join(__dirname, '../bin/ark/build-mac/bin/es2abc');
    if (fs.existsSync(es2abcFilePath)) {
      es2abc(receivedMsg);
    }
  }
}

function es2abc(receivedMsg) {
  try {
    const transCode = spawn(es2abcFilePath,
      ['--base64Input', Buffer.from(receivedMsg.data.script).toString('base64'), '--base64Output'], {windowsHide: true});
    transCode.stdout.on('data', (data) => {
      receivedMsg.data.script = data.toString();
      nextResponse(receivedMsg);
    });
    transCode.stderr.on('data', (data) => {
      receivedMsg.data.script = '';
      nextResponse(receivedMsg);
    });
  } catch (e) {
    if (checkStatus) {
      getOverLengthCode(receivedMsg);
    } else {
      codeOverMaxlength = true;
      receivedMsg_ = receivedMsg;
    }
  }
}

function getOverLengthCode(receivedMsg) {
  writeFileSync(previewJsFilePath, receivedMsg.data.script);
  const cmd = '"' + es2abcFilePath + '" ' + previewJsFilePath + ' --output ' + previewAbcFilePath;
  execSync(cmd, {windowsHide: true});
  if (fs.existsSync(previewAbcFilePath)) {
    receivedMsg.data.script = fs.readFileSync(previewAbcFilePath).toString('base64');
  } else {
    receivedMsg.data.script = '';
  }
  nextResponse(receivedMsg);
}

function nextResponse(receivedMsg) {
  compileStatus = true;
  receivedMsg_ = receivedMsg;
  responseToPlugin();
}

function resolveDiagnostic(diagnostic) {
  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
  if (validateError(message)) {
    if (diagnostic.file) {
      const { line, character } =
        diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
      errorInfo.push(
        `ArkTS:ERROR File: ${diagnostic.file.fileName}:${line + 1}:${character + 1}\n ${message}\n`);
    } else {
      errorInfo.push(`ArkTS:ERROR: ${message}`);
    }
  }
}

function delayPrintLogCount() {
  if (start == true) {
    checkStatus = true;
    if (codeOverMaxlength && !errorInfo.length && !receivedMsg_.data.log.length) {
      getOverLengthCode(receivedMsg_);
    } else {
      if (codeOverMaxlength) {
        compileStatus = true;
      }
      responseToPlugin();
    }
  }
}

function responseToPlugin() {
  if ((compileWithCheck !== 'true' && compileStatus == true) ||
    (compileWithCheck === 'true' && compileStatus == true && checkStatus == true)) {
    if (receivedMsg_) {
      if (errorInfo && errorInfo.length) {
        receivedMsg_.data.log =  receivedMsg_.data.log || [];
        receivedMsg_.data.log.push(...errorInfo);
      }
      if (callback) {
        callback(JSON.stringify(receivedMsg_));
        afterResponse();
      } else {
        pluginSocket.send(JSON.stringify(receivedMsg_), (err) => {
          afterResponse();
        });
      }
    }
  }
}

function afterResponse() {
  start = false;
  checkStatus = false;
  compileStatus = false;
  codeOverMaxlength = false;
  errorInfo = [];
  receivedMsg_ = undefined;
  globalDeclaration.clear();
  messages.shift();
  if (messages.length > 0) {
    handlePluginCompileComponent();
  }
}

function validateError(message) {
  const stateInfoReg = /Property\s*'(\$?[_a-zA-Z0-9]+)' does not exist on type/;
  const $$InfoReg = /Cannot find name\s*'(\$\$[_a-zA-Z0-9]+)'/;
  if (matchMessage(message, [...propertyVariable, ...props], stateInfoReg) ||
    matchMessage(message, [...dollarCollection], $$InfoReg)) {
    return false;
  }
  return true;
}

function matchMessage(message, nameArr, reg) {
  if (reg.test(message)) {
    const match = message.match(reg);
    if (match[1] && nameArr.includes(match[1])) {
      return true;
    }
  }
  return false;
}

module.exports = {
  init,
  buildPipeServer
};