// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.5.0 <0.9.0;

import {HederaResponseCodes} from "../../common/HederaResponseCodes.sol";
import {HederaTokenService} from "../../token-service/HederaTokenService.sol";
import {IHederaTokenService} from "../../token-service/IHederaTokenService.sol";
pragma experimental ABIEncoderV2;

// @title Airdrop Contract
// @notice Facilitates token airdrops for both fungible and non-fungible tokens
// @dev Implements HRC-904 standard for token airdrops
//
// Recipients will receive tokens in one of these ways:
// - Immediately if already associated with the token
// - Immediately with auto-association if they have available slots
// - As a pending airdrop requiring claim if they have "receiver signature required"
// - As a pending airdrop requiring claim if they have no available auto-association slots
//
// All transfer fees and auto-renewal rent costs are charged to the transaction submitter
contract Airdrop is HederaTokenService {
    // @notice Airdrops a fungible token from a sender to a single receiver
    // @dev Builds airdrop struct and submits airdropTokens system contract call
    // @param token The token address to airdrop
    // @param sender The address sending the tokens
    // @param receiver The address receiving the tokens
    // @param amount The amount of tokens to transfer
    // @return responseCode The response code from the airdrop operation (22 = success)
    function tokenAirdrop(address token, address sender, address receiver, int64 amount) public payable returns (int64 responseCode) {
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](1);
        IHederaTokenService.TokenTransferList memory airdrop;

        airdrop.token = token;
        airdrop.transfers = createAccountTransferPair(sender, receiver, amount);
        tokenTransfers[0] = airdrop;
        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Airdrops a non-fungible token from a sender to a single receiver
    // @dev Builds NFT airdrop struct and submits airdropTokens system contract call
    // @param token The NFT token address
    // @param sender The address sending the NFT
    // @param receiver The address receiving the NFT
    // @param serial The serial number of the NFT to transfer
    // @return responseCode The response code from the airdrop operation (22 = success)
    function nftAirdrop(address token, address sender, address receiver, int64 serial) public payable returns (int64 responseCode) {
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](1);
        IHederaTokenService.TokenTransferList memory airdrop;

        airdrop.token = token;
        IHederaTokenService.NftTransfer memory nftTransfer = prepareNftTransfer(sender, receiver, serial);
        IHederaTokenService.NftTransfer[] memory nftTransfers = new IHederaTokenService.NftTransfer[](1);
        nftTransfers[0] = nftTransfer;
        airdrop.nftTransfers = nftTransfers;
        tokenTransfers[0] = airdrop;
        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Airdrops multiple fungible tokens of the same amount from a sender to a single receiver
    // @dev Builds multiple token transfer structs and submits a single airdropTokens system contract call
    // @param tokens Array of token addresses to airdrop
    // @param sender The address sending all tokens
    // @param receiver The address receiving all tokens
    // @param amount The amount of each token to transfer
    // @return responseCode The response code from the airdrop operation (22 = success)
    function multipleFtAirdrop(address[] memory tokens, address sender, address receiver, int64 amount) public payable returns (int64 responseCode) {
        uint256 length = tokens.length;
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](length);
        for (uint256 i = 0; i < length; i++)
        {
            IHederaTokenService.TokenTransferList memory airdrop;
            airdrop.token = tokens[i];
            airdrop.transfers = createAccountTransferPair(sender, receiver, amount);
            tokenTransfers[i] = airdrop;
        }
        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Airdrops multiple NFTs from a sender to a single receiver
    // @dev Builds multiple NFT transfer structs and submits a single airdropTokens system contract call
    // @param nfts Array of NFT token addresses
    // @param sender The address sending all NFTs
    // @param receiver The address receiving all NFTs
    // @param serials Array of serial numbers corresponding to each NFT
    // @return responseCode The response code from the airdrop operation (22 = success)
    function multipleNftAirdrop(address[] memory nfts, address sender, address receiver, int64[] memory serials) public returns (int64 responseCode) {
        uint256 length = nfts.length;
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](length);
        for (uint256 i = 0; i < length; i++)
        {
            IHederaTokenService.TokenTransferList memory airdrop;
            airdrop.token = nfts[i];
            IHederaTokenService.NftTransfer[] memory nftTransfers = new IHederaTokenService.NftTransfer[](1);
            nftTransfers[0] = prepareNftTransfer(sender, receiver, serials[i]);
            airdrop.nftTransfers = nftTransfers;
            tokenTransfers[i] = airdrop;
        }
        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Distributes the same amount of a fungible token from one sender to multiple receivers
    // @dev Optimizes gas by building a single transfer list with multiple receivers
    // @param token The token address to distribute
    // @param sender The address sending the tokens
    // @param receivers Array of addresses to receive the tokens
    // @param amount The amount each receiver should get
    // @return responseCode The response code from the airdrop operation (22 = success)
    function tokenAirdropDistribute(
        address token,
        address sender,
        address[] memory receivers,
        int64 amount
    ) public payable returns (int64 responseCode) {
        uint256 length = receivers.length + 1;

        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](1);
        IHederaTokenService.TokenTransferList memory airdrop;
        airdrop.token = token;

        IHederaTokenService.AccountAmount memory senderAA;
        senderAA.accountID = sender;

        int64 totalAmount = 0;
        for (uint i = 0; i < receivers.length; i++) {
            totalAmount += amount;
        }
        senderAA.amount = -totalAmount;

        IHederaTokenService.AccountAmount[] memory transfers = new IHederaTokenService.AccountAmount[](length);
        transfers[0] = senderAA;

        for (uint i = 1; i < length; i++) {
            IHederaTokenService.AccountAmount memory receiverAA;
            receiverAA.accountID = receivers[i - 1];
            receiverAA.amount = amount;
            transfers[i] = receiverAA;
        }

        airdrop.transfers = transfers;
        tokenTransfers[0] = airdrop;

        responseCode = airdropTokens(tokenTransfers);

        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }

        return responseCode;
    }

    // @notice Distributes sequential NFTs from one sender to multiple receivers
    // @dev Assigns sequential serial numbers starting from 1 to each receiver
    // @param token The NFT token address
    // @param sender The address sending the NFTs
    // @param receivers Array of addresses to receive the NFTs
    // @param serials Array of serial numbers to assign to each receiver
    // @return responseCode The response code from the airdrop operation (22 = success)
    function nftAirdropDistribute(address token, address sender, address[] memory receivers, int64[] memory serials) public payable returns (int64 responseCode) {
        uint256 length = receivers.length;
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](1);
        IHederaTokenService.TokenTransferList memory airdrop;
        airdrop.token = token;
        IHederaTokenService.NftTransfer[] memory nftTransfers = new IHederaTokenService.NftTransfer[](length);
        for (uint i = 0; i < length; i++) {
            nftTransfers[i] = prepareNftTransfer(sender, receivers[i], serials[i]);
        }
        airdrop.nftTransfers = nftTransfers;
        tokenTransfers[0] = airdrop;

        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Performs a mixed airdrop of both fungible and non-fungible tokens
    // @dev Combines multiple token types into a single airdropTokens call for gas efficiency
    // @param token Array of fungible token addresses
    // @param nft Array of NFT token addresses
    // @param tokenSenders Array of addresses sending the fungible tokens
    // @param tokenReceivers Array of addresses receiving the fungible tokens
    // @param nftSenders Array of addresses sending the NFTs
    // @param nftReceivers Array of addresses receiving the NFTs
    // @param tokenAmount Amount of each fungible token to transfer
    // @param serials Array of serial numbers for the NFTs
    // @return responseCode The response code from the airdrop operation (22 = success)
    function mixedAirdrop(address[] memory token, address[] memory nft, address[] memory tokenSenders, address[] memory tokenReceivers, address[] memory nftSenders, address[] memory nftReceivers, int64 tokenAmount, int64[] memory serials) public payable returns (int64 responseCode) {
        uint256 length = tokenSenders.length + nftSenders.length;
        IHederaTokenService.TokenTransferList[] memory tokenTransfers = new IHederaTokenService.TokenTransferList[](length);
        for (uint i = 0; i < tokenSenders.length; i++)
        {
            IHederaTokenService.TokenTransferList memory airdrop;
            airdrop.token = token[i];
            airdrop.transfers = createAccountTransferPair(tokenSenders[i], tokenReceivers[i], tokenAmount);
            tokenTransfers[i] = airdrop;
        }
        uint nftIndex = tokenSenders.length;
        for (uint v = 0; nftIndex < length; v++)
        {
            IHederaTokenService.TokenTransferList memory airdrop;
            airdrop.token = nft[v];
            IHederaTokenService.NftTransfer[] memory nftTransfers = new IHederaTokenService.NftTransfer[](1);
            nftTransfers[0] = prepareNftTransfer(nftSenders[v], nftReceivers[v], serials[v]);
            airdrop.nftTransfers = nftTransfers;
            tokenTransfers[nftIndex] = airdrop;
            nftIndex++;
        }
        responseCode = airdropTokens(tokenTransfers);
        if (responseCode != HederaResponseCodes.SUCCESS) {
            revert();
        }
        return responseCode;
    }

    // @notice Internal helper to prepare AccountAmount array for token transfers
    // @dev Creates a transfer pair with negative amount for sender and positive for receiver
    // @param sender The address sending tokens
    // @param receiver The address receiving tokens
    // @param amount The amount to transfer
    // @return transfers Array containing the sender and receiver transfer details
    function createAccountTransferPair(address sender, address receiver, int64 amount) internal pure returns (IHederaTokenService.AccountAmount[] memory transfers) {
        IHederaTokenService.AccountAmount memory aa1;
        aa1.accountID = sender;
        aa1.amount = -amount;
        IHederaTokenService.AccountAmount memory aa2;
        aa2.accountID = receiver;
        aa2.amount = amount;
        transfers = new IHederaTokenService.AccountAmount[](2);
        transfers[0] = aa1;
        transfers[1] = aa2;
        return transfers;
    }

    // @notice Internal helper to prepare NFT transfer struct
    // @dev Sets up sender, receiver and serial number for an NFT transfer
    // @param sender The address sending the NFT
    // @param receiver The address receiving the NFT
    // @param serial The serial number of the NFT
    // @return nftTransfer The prepared NFT transfer struct
    function prepareNftTransfer(address sender, address receiver, int64 serial) internal pure returns (IHederaTokenService.NftTransfer memory nftTransfer) {
        nftTransfer.senderAccountID = sender;
        nftTransfer.receiverAccountID = receiver;
        nftTransfer.serialNumber = serial;
        return nftTransfer;
    }
}