// SPDX-License-Identifier: UNDEFINED

pragma solidity ^0.8.17;

/*
 * 区块链微博程序
 */
contract MicroBlog {
    address admin;

    bool is_running = true;

    string app_name; // 应用程序的名称

    uint256 blog_id; // 微博ID，从1开始递增

    uint256 blog_count; // 微博数量

    uint256[] id_array; // 所有微博ID数组

    mapping(uint256 => bool) has_id; // 是否包含当前ID

    mapping(uint256 => Blog) blogs; // 所有微博集合

    event AddBlog(uint256 id, string log); // 发布微博事件

    event DeleteBlog(uint256 id, string log); // 删除微博事件

    // 微博结构体
    struct Blog {
        uint256 time;
        address owner;
        string content;
    }

    constructor() payable {
        admin = msg.sender;
    }

    // 设置APP名称
    function setAppName(string memory _name) external {
        app_name = _name;
    }

    // 发布一条微博
    function addBlog(string memory _content) public isRunning {
        blog_id++;
        id_array.push(blog_id);
        has_id[blog_id] = true;
        blogs[blog_id] = Blog(block.timestamp, msg.sender, _content);
        emit AddBlog(blog_id, _content);
        blog_count++;
    }

    // 删除一条微博
    function delBlogById(uint256 _id) public canAccess(_id) {
        if (has_id[_id]) {
            delete blogs[_id];
            delete has_id[_id];
            blog_count--;
            emit DeleteBlog(_id, blogs[_id].content);
        }
    }

    // 根据ID查看微博
    function getBlogById(uint256 id) public view returns (Blog memory) {
        return blogs[id];
    }

    // 查询指定用户的所有微博
    function getBlogByAddress(address _address)
        public
        view
        returns (Blog[] memory)
    {
        // 计算该用户的微博数量
        uint256 _user_count;
        for (uint256 i = 0; i < id_array.length; i++) {
            if (has_id[id_array[i]]) {
                if (blogs[id_array[i]].owner == _address) {
                    _user_count++;
                }
            }
        }
        // 查询该用户名下的微博
        uint256 index;
        Blog[] memory _blogs = new BlogUnsupported embed;
        for (uint256 i = 0; i < id_array.length; i++) {
            if (has_id[id_array[i]]) {
                if (blogs[id_array[i]].owner == msg.sender) {
                    _blogs[index] = blogs[id_array[i]];
                    index++;
                }
            }
        }
        return _blogs;
    }

    // 获取所有id
    function getBlogIds() public view returns (uint256[] memory) {
        uint256[] memory _result = new uint256Unsupported embed;
        uint256 index;
        for (uint256 i = 0; i < id_array.length; i++) {
            if (has_id[id_array[i]]) {
                _result[index] = id_array[i];
                index++;
            }
        }
        return _result;
    }

    // 所有微博数量
    function getBlogCount() public view returns (uint256) {
        return blog_count;
    }

    // 设置合约运行状态
    function setIsRunning(bool _running) public isAdmin {
        is_running = _running;
    }

    // 变更合约的管理员
    function changeOwner(address _newOwner) external {
        admin = _newOwner;
    }

    // 只有合约管理员才可以提取资金
    function withdraw(uint256 _amount) public payable isAdmin {
        payable(admin).transfer(_amount);
    }

    // 只有合约管理员才可以提取全部资金
    function withdrawAll() public payable isAdmin {
        payable(admin).transfer(address(this).balance);
    }

    // 销毁合约
    function destruct() public isAdmin {
        selfdestruct(payable(admin));
    }

    // 是否为合约管理员
    modifier isAdmin() {
        require(msg.sender == admin, "must be admin!");
        _;
    }

    // 合约是否在正常运行
    modifier isRunning() {
        require(is_running, "contract is stopped!");
        _;
    }

    // 用户仅可操作自己的微博(管理员除外)
    modifier canAccess(uint256 _id) {
        require(
            msg.sender == admin || msg.sender == blogs[_id].owner,
            "permission denied!"
        );
        _;
    }
}