<?php

namespace services;

require_once('models/Chip.php');
require_once('models/Nft.php');
require_once('models/NftActive.php');
require_once('mt/Item.php');

use models\Chip;
use models\NftActive;
use models\Nft;
use mt\Item;
use phpcommon\SqlHelper;

class NftService extends BaseService {

    private static $userData = array();
    private static $nftCfg = array(
        'hero' => Nft::HERO_TYPE,
        'normal_hero' => Nft::GCARD_HERO_TYPE,
        'equip' => Nft::EQUIP_TYPE,
        'chip' => Nft::CHIP_TYPE,
        'ring' => Nft::RING_TYPE,
        'avatar' => Nft::AVATAR_TYPE,
    );

    public static function getChipBlance($account, $tokenId)
    {
        return Nft::getChipBlance($account, $tokenId);
    }

    public static function isAvatarOwner($openId, $tokenId)
    {
        return self::internalIsOwner($openId, 'avatar', $tokenId);
    }

    public static function isHeroOwner($openId, $tokenId)
    {
        return self::internalIsOwner($openId, 'hero', $tokenId) ||
            self::internalIsOwner($openId, 'normal_hero', $tokenId);;
    }

    public static function isEquipOwner($openId, $tokenId)
    {
        return self::internalIsOwner($openId, 'equip', $tokenId);
    }

    public static function isChipOwner($openId, $tokenId)
    {
        return self::internalIsOwner($openId, 'chip', $tokenId);
    }

    public static function getHeros($openId)
    {
        $heros = self::internalGetList($openId, 'hero');
        $normalHeros = self::internalGetList($openId, 'normal_hero');
        return array_merge($heros, $normalHeros);
    }

    public static function getEquips($openId)
    {
        return self::internalGetList($openId, 'equip');
    }

    public static function getChips($openId)
    {
        return self::internalGetList($openId, 'chip');
    }

    public static function getRing($openId)
    {
        return self::internalGetList($openId, 'ring');
    }
    public static function getAvatar($openId)
    {
        return self::internalGetList($openId, 'avatar');
    }

    private static function internalGetList($openId, $name)
    {
        self::loadNft($openId, $name);
        return getXVal(self::$userData[$openId], $name . 'List');
    }

    private static function internalIsOwner($openId, $name, $tokenId)
    {
        self::loadNft($openId, $name);
        $nftHash = getXVal(self::$userData[$openId], $name . 'Hash', array());
        $nftDb = getXVal($nftHash, $tokenId);
        //return $nftDb && $nftDb['owner_address'] == $openId;
        if (empty($nftDb)) {
            return null;
        }
        return $nftDb['owner_address'] == LOCK_CONTRACT_ADDRESS &&
                                       $nftDb['last_lock_address'] == $openId;
    }

    private static function loadNft($openId, $name)
    {
        if (!in_array($openId, self::$userData)) {
            self::$userData[$openId] = array();
        }
        if (!in_array($name . 'List', self::$userData[$openId])) {
            $listName = $name . 'List';
            $hashName = $name . 'Hash';
            $tokenType = self::$nftCfg[$name];
            self::$userData[$openId][$listName] = Nft::GetNftListByType($openId, $tokenType);
            self::$userData[$openId][$hashName] = array();
            foreach (self::$userData[$openId][$listName] as $nftDb) {
                self::$userData[$openId][$hashName][$nftDb['token_id']] = $nftDb;
            }
        }
    }

    public static function addNftActive($nftDb,$type){
        if (!$nftDb){
            return ;
        }
        switch ($type){
            case Nft::HERO_TYPE:
                {
                    $data = array(
                        'uniid' => $nftDb['hero_uniid'],
                        'token_id' => $nftDb['token_id'],
                        'token_type' => Nft::HERO_TYPE,
                    );
                    NftActive::upsert($data);
                    if ($nftDb['chip_ids']){
                        $chip_ids = explode("|",$nftDb['chip_ids']);
                        if (count($chip_ids)>0){
                            foreach ($chip_ids as $chip_id){
                                $chipDb = Chip::getChipByIdx($chip_id);
                                self::addNftActive($chipDb,Nft::CHIP_TYPE);
                            }
                        }
                    }
                }
                break;
            case Nft::EQUIP_TYPE:
                {
                    $data = array(
                        'uniid' => $nftDb['gun_uniid'],
                        'token_id' => $nftDb['token_id'],
                        'token_type' => Nft::EQUIP_TYPE,
                    );
                    NftActive::upsert($data);
                    if ($nftDb['chip_ids']){
                        $chip_ids = explode("|",$nftDb['chip_ids']);
                        if (count($chip_ids)>0){
                            foreach ($chip_ids as $chip_id){
                                $chipDb = Chip::getChipByIdx($chip_id);
                                self::addNftActive($chipDb,Nft::CHIP_TYPE);
                            }
                        }
                    }
                }
                break;
            case Nft::CHIP_TYPE:
                {
                    $data = array(
                        'uniid' => $nftDb['idx'],
                        'token_id' => $nftDb['token_id'],
                        'token_type' => Nft::CHIP_TYPE,
                    );
                    NftActive::upsert($data);
                }
                break;
            default:
            {

            }
        }
    }

    public static function hasAnyNft($accountAddress)
    {
        {
            $nftList = Nft::getNftListByType($accountAddress, Nft::HERO_TYPE);
            if (!empty($nftList) || count($nftList) > 0) {
                return true;
            }
        }
        {
            $nftList = Nft::getOwnerNftListByType($accountAddress, Nft::HERO_TYPE);
            if (!empty($nftList) || count($nftList) > 0) {
                return true;
            }
        }
        return false;
    }

}