// SPDX-License-Identifier: unlicensed
// (c) Copyright 2024 Kolibri GmbH, all rights reserved
pragma solidity ^0.8.9;

import '../../core/interfaces/one-to-one/ISwapFactory.sol';
import '../interfaces/one-to-one/ISwapRouter.sol';
import '../../core/interfaces/ISwapPair.sol';
import '../../core/interfaces/ISwapERC20.sol';
import '../libraries/SafeMath.sol';

contract SwapRouter is ISwapRouter {
  using SafeMath for uint;

  address public immutable override factory;
  address public immutable override WETH;

  modifier ensure(uint deadline) {
    require(deadline >= block.timestamp, 'SwapRouter: EXPIRED');
    _;
  }

  uint private unlocked = 1;
  modifier lock() {
    require(unlocked == 1, 'Swap: LOCKED');
    unlocked = 0;
    _;
    unlocked = 1;
  }

  modifier onlyNormal() {
    if (ISwapFactory(factory).getEoaWhitelist(msg.sender)) {
    } else {
      require(tx.origin == msg.sender, 'SwapRouter: onlyNormal failed'); 
    }
    _;
  }

  modifier once(address pair) {
    if (!ISwapFactory(factory).getOnce(pair, msg.sender)) {
    } else {
      if (ISwapFactory(factory).getEoaWhitelist(msg.sender)) {
      } else {
        require(false, 'SwapRouter: Once failed');
      }
    }
    _;
    ISwapFactory(factory).addOnce(pair, msg.sender);
  }

  constructor(address _factory, address _WETH) {
    factory = _factory;
    WETH = _WETH;
  }

  receive() external payable {
    assert(msg.sender == WETH); // only accept ETH via fallback from the WETH contract
  }

  function getBlockNumber() private view onlyNormal returns (uint blockNumber) {
    blockNumber = block.number;
  }

  // **** ADD LIQUIDITY ****
  function _addLiquidity(
    address tokenA,
    address tokenB,
    uint amountADesired,
    uint amountBDesired
  ) private onlyNormal returns (uint amountA, uint amountB) {
    // create the pair if it doesn't exist yet
    if (ISwapFactory(factory).getPair(tokenA, tokenB) == address(0)) {
      ISwapFactory(factory).createPair(tokenA, tokenB);
    }
    (amountA, amountB) = (amountADesired, amountBDesired);
  }

  function addLiquidity(
    address tokenA,
    address tokenB,
    uint amountADesired,
    uint amountBDesired,
    address to,
    uint deadline
  ) external override ensure(deadline) lock onlyNormal once(pairFor(tokenA, tokenB)) returns (uint amountA, uint amountB, uint liquidity) {
    (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired);
    address pair = pairFor(tokenA, tokenB);
    safeTransferFrom(tokenA, msg.sender, pair, amountA);
    safeTransferFrom(tokenB, msg.sender, pair, amountB);
    liquidity = ISwapPair(pair).mint(to);
    ISwapFactory(factory).addTime(pair, msg.sender);
  }

  // **** REMOVE LIQUIDITY ****
  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint liquidity,
    address to,
    uint deadline
  ) public override ensure(deadline) lock onlyNormal returns (uint amountA, uint amountB) {
    address pair = pairFor(tokenA, tokenB);
    require(ISwapFactory(factory).getTime(pair, msg.sender) + ISwapFactory(factory).getTimeToElapse() < getBlockNumber(), 'SwapRouter: Wait for elapsed time');
    ISwapPair(pair).transferFrom(msg.sender, pair, liquidity, factory); // send liquidity to pair
    (uint amount0, uint amount1) = ISwapPair(pair).burn(to);
    (address token0, ) = sortTokens(tokenA, tokenB);
    (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
  }

  // **** SWAP ****
  // requires the initial amount to have already been sent to the first pair
  function _swap(uint[] memory amounts, address[] memory path, address _to) private {
    for (uint i; i < path.length - 1; i++) {
      (address input, address output) = (path[i], path[i + 1]);
      (address token0, ) = sortTokens(input, output);
      uint amountOut = amounts[i + 1];
      (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
      address to = i < path.length - 2 ? pairFor(output, path[i + 2]) : _to;
      ISwapPair(pairFor(input, output)).swap(amount0Out, amount1Out, to, new bytes(0));
    }
  }

  function swapExactTokensForTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
  ) external override ensure(deadline) lock onlyNormal returns (uint[] memory amounts) {
    amounts = getAmountsOutInternal(amountIn, path);
    require(amounts[amounts.length - 1] >= amountOutMin, 'SwapRouter: INSUFFICIENT_OUTPUT_AMOUNT');
    safeTransferFrom(path[0], msg.sender, pairFor(path[0], path[1]), amounts[0]);
    _swap(amounts, path, to);
  }

  function doubleSwapExactTokensForTokens(
    uint amountInFirst,
    uint amountInSecond,
    uint amountOutMinFirst,
    uint amountOutMinSecond,
    address[] calldata pathFirst,
    address[] calldata pathSecond,
    address toSecond,
    uint deadline
  ) external override ensure(deadline) lock onlyNormal returns (uint[] memory amountsFirst, uint[] memory amountsSecond) {

    // Make sure it is a double swap
    require(pathFirst[0] == pathSecond[1] && pathFirst[1] == pathSecond[0], 'SwapRouter: INPUT_PATH_MISMATCHING');

    // First swap
    amountsFirst = getAmountsOutInternal(amountInFirst, pathFirst);
    require(amountsFirst[amountsFirst.length - 1] >= amountOutMinFirst, 'SwapRouter: INSUFFICIENT_OUTPUT_AMOUNT');
    safeTransferFrom(pathFirst[0], msg.sender, pairFor(pathFirst[0], pathFirst[1]), amountsFirst[0]);
    _swap(amountsFirst, pathFirst, msg.sender);

    // Second swap
    amountsSecond = getAmountsOutInternal(amountInSecond, pathSecond);
    require(amountsSecond[amountsSecond.length - 1] >= amountOutMinSecond, 'SwapRouter: INSUFFICIENT_OUTPUT_AMOUNT');
    safeTransferFrom(pathSecond[0], msg.sender, pairFor(pathSecond[0], pathSecond[1]), amountsSecond[0]);
    _swap(amountsSecond, pathSecond, toSecond);
  }

  function getAmountsOut(
    uint amountIn,
    address[] memory path
  ) public override lock onlyNormal returns (uint[] memory amounts) {
    return getAmountsOutInternal(amountIn, path);
  }

  function safeTransferFrom(
    address token,
    address from,
    address to,
    uint256 value
  ) private onlyNormal {
      // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
      (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
      require(
          success && (data.length == 0 || abi.decode(data, (bool))),
          'SwapRouter::transferFrom: transferFrom failed'
      );
  }

  // returns sorted token addresses, used to handle return values from pairs sorted in this order
  function sortTokens(address tokenA, address tokenB) private view onlyNormal returns (address token0, address token1) {
    require(tokenA != tokenB, 'SwapRouter: IDENTICAL_ADDRESSES');
    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), 'SwapRouter: ZERO_ADDRESS');
  }

  function pairFor(address tokenA, address tokenB) private view onlyNormal returns (address pair) {
    (address token0, address token1) = sortTokens(tokenA, tokenB);
    pair = ISwapFactory(factory).getPair(token0, token1);
  }

  // fetches and sorts the reserves for a pair
  function getReserves(
    address tokenA,
    address tokenB
  ) private view onlyNormal returns (uint reserveA, uint reserveB) {
    (address token0, ) = sortTokens(tokenA, tokenB);
    (uint reserve0, uint reserve1, ) = ISwapPair(pairFor(tokenA, tokenB)).getReserves();
    (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
  }

    // given an input amount of an asset returns the maximum output amount of the other asset
  function getAmountOut(
    uint amountIn,
    uint reserveIn,
    uint reserveOut,
    address outTokenAddr,
    address inTokenAddr
  ) private view onlyNormal returns (uint amountOut) {
    require(amountIn > 0, 'SwapRouter: INSUFFICIENT_INPUT_AMOUNT');
    require(reserveIn > 0 && reserveOut > 0, 'SwapRouter: INSUFFICIENT_LIQUIDITY');
    ISwapERC20 outToken = ISwapERC20(outTokenAddr);
    ISwapERC20 inToken = ISwapERC20(inTokenAddr);
    uint amount;
    if (outToken.decimals() == inToken.decimals()) {
      amount = amountIn;
    } else {
      if (outToken.decimals() > inToken.decimals()) {
        uint8 decimalsDiff = outToken.decimals() - inToken.decimals();
        amount = amountIn * 10 ** decimalsDiff;
      } else {
        uint8 decimalsDiff = inToken.decimals() - outToken.decimals();
        amount = amountIn / 10 ** decimalsDiff;
      }
    }
    ISwapFactory factoryInstance = ISwapFactory(factory);

    // If swapped from any to UHU / ALPHA / ...: Deduct fee
    uint amountAfterSwappingFee;
    if (factoryInstance.feeableTokens(outTokenAddr)) {
      amountAfterSwappingFee = amount.mul((1000 - factoryInstance.getFeeBase())) / 1000;
    } else { 
      // If swapped from any to any: Deduct no fee; 1:1 curve
      amountAfterSwappingFee = amount;
    }
    
    // If inToken is feeable
    if (factoryInstance.feeableTokens(inTokenAddr)) {
      if (factoryInstance.feeableTokens(outTokenAddr)) {
        amountOut = amountAfterSwappingFee;
      } else {
        amountOut = amountAfterSwappingFee * 1000 / factoryInstance.getCurrencyConversion(outTokenAddr);
      }
    } else { // If inToken is not feeable (all other tokens)
      if (factoryInstance.feeableTokens(outTokenAddr)) {
        amountOut = amountAfterSwappingFee.mul(factoryInstance.getCurrencyConversion(inTokenAddr)) / 1000;
      } else {
        amountOut = amountAfterSwappingFee * factoryInstance.getCurrencyConversion(inTokenAddr) / factoryInstance.getCurrencyConversion(outTokenAddr);
      }
    }
  }

  // performs chained getAmountOut calculations on any number of pairs
  function getAmountsOutInternal(
    uint amountIn,
    address[] memory path
  ) private view onlyNormal returns (uint[] memory amounts) {
    require(path.length >= 2, 'SwapRouter: INVALID_PATH');
    amounts = new uint[](path.length);
    amounts[0] = amountIn;
    for (uint i; i < path.length - 1; i++) {
      (uint reserveIn, uint reserveOut) = getReserves(path[i], path[i + 1]);
      amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut, path[i + 1], path[i]);
    }
  }

}