<?php

namespace models;

require_once('mt/Attr.php');
require_once('mt/Hero.php');
require_once('mt/Item.php');
require_once('mt/Equip.php');
require_once('mt/GunLevel.php');
require_once('mt/GunQuality.php');

use mt;
use phpcommon\SqlHelper;
use phpcommon;

class Nft extends BaseModel
{

    const NONE_TYPE = 0;
    const HERO_TYPE = 1;        //英雄
    const EQUIP_TYPE = 2;       //枪械
    const CHIP_TYPE = 3;        //芯片
    const BLIND_BOX_TYPE = 4;
    const FRAGMENT_TYPE = 5;    //碎片
    const HONOR1_TYPE = 6;    //荣誉
    const GENESIS_TYPE = 7;    //创世徽章
    const PLANET_TYPE = 8;    //星球
    const EXPLORER_TYPE = 9;    //Explorer
    const CANDY_TYPE = 10;    //CANDY
    const GOLD_BULLION_TYPE = 11;    //金砖
    const GCARD_HERO_TYPE = 12;    //游戏内合成的nft英雄
    const FOUNDER_TAG_TYPE = 13;    //游戏内合成的nft英雄
    const RING_TYPE = 19;    //戒指
    const AVATAR_TYPE = 30;    //装饰

    const GENESIS_TAG = 1;

    public static function getTokenType($itemMeta)
    {
        switch ($itemMeta['type']) {
            case mt\Item::HERO_TYPE:
                {
                    return self::HERO_TYPE;
                }
                break;
            case mt\Item::GUN_TYPE:
                {
                    return self::EQUIP_TYPE;
                }
                break;
            case mt\Item::MATERIAL_TYPE:
                {
                    if ($itemMeta['sub_type'] == mt\Item::MATERIAL_CHIP_SUBTYPE) {
                        return self::CHIP_TYPE;
                    }
                }
                break;
            case mt\Item::BLIND_BOX_TYPE:
                {
                    return self::BLIND_BOX_TYPE;
                }
                break;
            case mt\Item::CHIP_TYPE:
                {
                    return self::CHIP_TYPE;
                }
                break;
            case mt\Item::FRAGMENT_BOX_TYPE:
                {
                    return self::FRAGMENT_TYPE;
                }
                break;
            case mt\Item::RING_TYPE:
            {
                return self::RING_TYPE;
            }
            case mt\Item::HONOR_TYPE:
            {
                return self::HONOR1_TYPE;
            }
        }
        return self::NONE_TYPE;
    }

    public static function getNftList($account)
    {
        $nftList = array();
        SqlHelper::ormSelect(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'owner_address' => $account,
                'deleted' => 0,
            ),
            function ($row) use (&$nftList) {
                if (self::isVisableNft($row)) {
                    array_push($nftList, $row);
                }
            }
        );
        return $nftList;
    }

    public static function getChipBlance($account, $tokenId)
    {
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft1155',
            array(
                'owner_address' => $account,
                'token_id' => $tokenId,
            )
        );
        return $row ? $row['balance'] : 0;
    }

    public static function getNftListByType($account, $type)
    {
        $nftList = array();
        SqlHelper::ormSelect(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'owner_address' => LOCK_CONTRACT_ADDRESS,
                'last_lock_address' => $account,
                'token_type' => $type,
                'deleted' => 0,
            ),
            function ($row) use (&$nftList) {
                array_push($nftList, $row);
            }
        );
        return $nftList;
    }

    public static function getOwnerNftListByType($account, $type)
    {
        $nftList = array();
        SqlHelper::ormSelect(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'owner_address' => $account,
                'token_type' => $type,
                'deleted' => 0,
            ),
            function ($row) use (&$nftList) {
                array_push($nftList, $row);
            }
        );
        return $nftList;
    }

    public static function getNft1155List($account, $type)
    {

        switch ($type) {
            case 3:
                {
                    $sql = "select * from t_nft1155 where owner_address=:owner_address and token_id>10000000 and balance>0";
                };
                break;
            case 5:
                {
                    $sql = "select * from t_nft1155 where owner_address=:owner_address and token_id<10000000 and balance>0";
                };
                break;
            default:
            {
                $sql = "";
            }
        }
        $whereKv = array(
            'owner_address' => $account,
        );
        if ($sql) {
            $list = myself()->_getMarketMysql()->execQuery($sql, $whereKv);
        } else {
            $list = array();
        }
        return $list;
    }

    public static function getNft($tokenId)
    {
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'token_id' => $tokenId,
            )
        );
        return $row;
    }

    public static function getNftByNetIdTokenTypeTokenId($netId, $tokenType, $tokenId)
    {
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'net_id' => $netId,
                'token_id' => $tokenId,
                'token_type' => $tokenType,
            )
        );
        return $row;
    }

    public static function getNftByNetIdContractAddressTokenId($netId, $contractAddress, $tokenId)
    {
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'net_id' => $netId,
                'contract_address' => $contractAddress,
                'token_id' => $tokenId,
            )
        );
        return $row;
    }

    public static function getNftByNetCont($tokenId, $netId, $contractAddress)
    {
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'token_id' => $tokenId,
                'net_id' => $netId,
                'contract_address' => strtolower($contractAddress)
            )
        );
        return $row;
    }

    public static function findNftByOwner($owner, $tokenId)
    {
        if (!$owner || !$tokenId) {
            return;
        }
        $row = SqlHelper::ormSelectOne(
            myself()->_getMarketMysql(),
            't_nft',
            array(
                'owner_address' => $owner,
                'token_id' => $tokenId,
            )
        );
        if (!$row) {
            $row = SqlHelper::ormSelectOne(
                myself()->_getMarketMysql(),
                't_nft1155',
                array(
                    'owner_address' => $owner,
                    'token_id' => $tokenId,
                )
            );
            if ($row) {
                if ($row['token_id'] > 10000000) {
                    $row['token_type'] = self::CHIP_TYPE;
                    $row['token_state'] = 0;
                    $row['tags'] = '';
                } else {
                    $row['token_type'] = self::FRAGMENT_TYPE;
                    $row['token_state'] = 0;
                    $row['tags'] = '';
                    $row['item_id'] = $row['token_id'];
                }
            }
        }
        return $row;
    }

//    public static function addNftByFragmentBox($itemMeta,$num=0){
//        if ($itemMeta) {
//            $tokenType = Nft::getTokenType($itemMeta);
//            if ($tokenType == Nft::NONE_TYPE) {
//                return false;
//            } else {
//                SqlHelper::insert(
//                    myself()->_getMarketMysql(),
//                    't_nft',
//                    array(
//                        'token_id' => self::genTempTokenId(),
//                        'token_type' => $tokenType,
//                        'game_id' => 2006,
//                        'item_id' => $itemMeta['include_item_id'],
//                        'owner_address' => myself()->_getOpenId(),
//                        'createtime' => myself()->_getNowTime(),
//                        'modifytime' => myself()->_getNowTime(),
//                    )
//                );
//                return true;
//            }
//        } else {
//            return false;
//        }
//    }

//    public static function addNft($itemMeta){
//        if ($itemMeta) {
//            $tokenID = self::genTempTokenId();
//            $tokenType = Nft::getTokenType($itemMeta);
//
//            if ($tokenType == Nft::NONE_TYPE) {
//                return false;
//            } else {
//                SqlHelper::insert(
//                    myself()->_getMarketMysql(),
//                    't_nft',
//                    array(
//                        'token_id' => $tokenID,
//                        'token_type' => $tokenType,
//                        'game_id' => 2006,
//                        'item_id' => $itemMeta['id'],
//                        'owner_address' => myself()->_getOpenId(),
//                        'createtime' => myself()->_getNowTime(),
//                        'modifytime' => myself()->_getNowTime(),
//                    )
//                );
//                return $tokenID;
//            }
//        } else {
//            return false;
//        }
//    }

    private static function parseTags($tagsStr)
    {
        $tags = explode('|', $tagsStr);
        return $tags;
    }

    private static function isVisableNft($nftDb)
    {
        return in_array($nftDb['token_type'],
            array(
                self::HERO_TYPE,
                self::EQUIP_TYPE,
                self::CHIP_TYPE,
                self::BLIND_BOX_TYPE,
                self::FRAGMENT_TYPE,
                self::HONOR1_TYPE,
                self::RING_TYPE,
                self::GENESIS_TYPE,
                self::PLANET_TYPE,
                self::EXPLORER_TYPE
            ));
    }

    public static function genTempTokenId()
    {
        $row = SqlHelper::ormSelectOne
        (myself()->_getSelfMysql(),
            't_realtime_data',
            array(
                'name' => 'last_token_idx'
            )
        );
        $lastTokenIdx = 0;
        if ($row) {
            $lastTokenIdx = $row['value1'];
        }
        ++$lastTokenIdx;
        $tokenId = myself()->_getNowTime() . phpcommon\pad($lastTokenIdx % 999999, 6);
        if ($row) {
            SqlHelper::update
            (myself()->_getSelfMysql(),
                't_realtime_data',
                array(
                    'name' => 'last_token_idx'
                ),
                array(
                    'value1' => $lastTokenIdx
                )
            );
        } else {
            SqlHelper::insert
            (myself()->_getSelfMysql(),
                't_realtime_data',
                array(
                    'name' => 'last_token_idx',
                    'value1' => $lastTokenIdx,
                    'createtime' => myself()->_getNowTime(),
                    'modifytime' => myself()->_getNowTime()
                )
            );
        }

        return $tokenId;
    }

}