//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "hardhat/console.sol";

contract Greeter {
    string private greeting;

    constructor(string memory _greeting) {
        console.log("Deploying a Greeter with greeting:", _greeting);
        greeting = _greeting;
    }

    function greet() public view returns (string memory) {
        return greeting;
    }

    function setGreeting(string memory _greeting) public {
        console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
        greeting = _greeting;
    }
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ProductFactory {
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ProductFactory {
  string name;
  string category;
  string description;
  string image;
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ProductFactory {
  struct Product {
    string name;
    string category;
    string description;
    string image;
  }
}

// 2개의 원소를 담을 수 있는 고정 길이의 배열
uint[2] fixedArray;
// 동적 배열은 고정된 크기가 없으며 계속 크기가 커질 수 있다
uint[] dynamicArray;

// 데이터베이스처럼 구조화된 데이터를 저장 시킬 수 있어 유용하다.
Product[] products;

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ProductFactory {
  struct Product {
    string name;
    string category;
    string description;
    string image;
  }

	// 상품 배열을 공개 상태변수로 선언
	Product[] public products;
}

// 상품을 생성하는 함수, 외부에서만 사용하기 때문에 external로 지정한다.
// 솔리디티에서는 함수에 가시성과 같은 것들을 함수명 다음에 지정한다. 이런 것들을 함수에 속성이라고 한다.
function createProduct() external {}

// "_"는 전역 변수와 구별을 위한 관례이다.(필수는 아님)
function createProduct(
	string calldata _name,
	string calldata _category,
	string calldata _description,
	string calldata _image
) external {}

function createProduct(
	string calldata _name,
	string calldata _category,
	string calldata _description,
	string calldata _image
) external {
	// 상품 구조체 생성
	Product memory newProduct = Product(_name, _category, _description, _image);
	// 상태 변수에 추가한다.
	// push는 배열에 값을 넣을 때 사용된다.
	products.push(newProduct);
}

// 이벤트를 선언한다.
event IntegersAdded(uint x, uint y, uint result);

function add(uint calldata _x, uint calldata _y) external returns(uint memory) {
  uint memory result = _x + _y;
  // 이벤트를 실행하여 add 함수가 실행되었음을 알린다.
  emit IntegersAdded(_x, _y, result);

  return result;
}

// 이벤트를 선언한다.
event NewProduct(
    uint256 id,
    string name,
    string category,
    string description,
    string image
  );

function createProduct(
    string calldata _name,
    string calldata _category,
    string calldata _description,
    string calldata _image
  ) external {
    Product memory newProduct = Product(_name, _category, _description, _image);
    products.push(newProduct);

		// 추가된 상품의 색인, (uint256) 정수 타입은 저장 위치를 지정해 줄 필요가 없다.
    uint256 id = products.length - 1;
		// 상품이 추가된 후 이벤트가 발생한다.
    emit NewProduct(id, _name, _category, _description, _image);
  }

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ProductFactory {
  event NewProduct(
    uint256 id,
    string name,
    string category,
    string description,
    string image
  );

  struct Product {
    string name;
    string category;
    string description;
    string image;
  }

  Product[] public products;

  function createProduct(
    string calldata _name,
    string calldata _category,
    string calldata _description,
    string calldata _image
  ) external {
    Product memory newProduct = Product(_name, _category, _description, _image);
    products.push(newProduct);

    uint256 id = products.length - 1;

    emit NewProduct(id, _name, _category, _description, _image);
  }
}

const { expect } = require('chai');
const { ethers } = require('hardhat');

describe('ProductFactory', async function () {
  let productFactory;
  let newProductEvents = [];

  const product = [
    'MacBook-pro M1X 16inch',
    'apple',
    'MacBook-pro M1X 16inch, Space Gray, 64GB Memory, 8TB SSD Storage, Pre-Installed "Final Cut Pro" and "Logic Pro"',
    'https://store.storeimages.cdn-apple.com/8756/as-images.apple.com/is/mbp16-spacegray-gallery2-202110?wid=4000&hei=3072&fmt=jpeg&qlt=80&.v=1632799174000',
  ];

  before(async function () {
    const Factory = await ethers.getContractFactory('ProductFactory');
    const factory = await Factory.deploy();
    await factory.deployed();

    productFactory = factory;
  });

  it('#1 상품 생성하기', async function () {
    const createProduct = await productFactory.createProduct(...product);

    const receipt = await createProduct.wait();

    const events = receipt.events.filter((x) => {
      return x.event == 'NewProduct';
    });
    newProductEvents = events;

    expect(events).to.not.length(0);
  });

  it('#2 추가된 상품 조회하기', async function () {
    const lastEvent = newProductEvents.pop();
    const productId = lastEvent.args.id.toNumber();

    const { name, category, description, image, ...hot } = await productFactory.products(productId);
    const newProduct = Object.values(hot);

    expect(newProduct).deep.to.equal(product);
  });
});

// 외부 호출 함수이기 때문에 external로 설정, 스토리지 변경이 없기 때문에 view 함수이다
function balanceOf(address _owner) external view returns (uint256) {
	// 소유한 자산의 갯수를 반환한다
}
function ownerOf(uint256 _id) external view returns (address) {
		// 토큰의 소유자 주소를 반환한다
}

// 소유자 주소 => 소유한 상품 갯수, 소유자 주소를 조회하여 갯수를 반환한다.
mapping(address => uint256) public ownerProductCount;
// 상품 => 소유자 주소, 상품ID 값으로 조회하여 소유자 주소를 반환한다.
mapping(uint256 => address) public productToOwner;

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// ProductFactory의 모든 컨트랙트를 가져온다.
import './ProductFactory.sol';

contract ProductOwnership {
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './ProductFactory.sol';

contract ProductOwnership is ProductFactory {
	// ProductFactory를 상속받아 internal or public으로 선언된 모든 상태변수와 메서드를 사용

	/**
   * @dev 토큰 소유량 가져오기
   */
  function balanceOf(address _owner) public view virtual returns (uint256) {
		// ownerProductCount 상태변수는 해당 주소가 소유한 토큰의 총 수량을 나타냄
    return ownerProductCount[_owner];
  }

  /**
   * @dev 토큰 소유자 가져오기
   */
  function ownerOf(uint256 _tokenId) public view returns (address) {
		// productToOwner 상태변수는 해당 토큰의 소유자 주소를 나타냄
    return productToOwner[_tokenId];
  }
}

function transferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  ) private {
    ownerProductCount[_from]--;
    ownerProductCount[_to]++;

    productToOwner[_tokenId] = _to;

    emit Transfer(_from, _to, _tokenId);
  }

// 토큰 소유자가 승인한 계정들이 저장된다.
mapping(uint256 => address) private _approvals;

function approve(address _to, uint256 _tokenId) public {
  address owner = this.ownerOf(_tokenId);

	// 승인할 계정이 소유자일 경우 취소
	// 거짓일 경우 두번째 매개변수로 받은 에러 메세지를 EVM에 반환한다.
  require(_to != owner, 'Approval to current owner');
	// 호출자가 해당 토큰 소유자 맞는지 확인
  require(
    msg.sender == owner,
    'Approve caller is not owner nor approved for all'
  );

	// 상태변수에 저장
  _approve(_to, _tokenId);
}

/**
 * @dev 토큰 승인
 */
function _approve(address _to, uint256 _tokenId) private {
  _approvals[_tokenId] = _to;

  emit Approval(this.ownerOf(_tokenId), _to, _tokenId);
}

function transferFrom(
  address _from,
  address _to,
  uint256 _tokenId
) external {
  require(
		// 승인 받은 구매자 또는 소유자 인지 확인
		// 소유자는 해당 메서드를 호출할 수 있다.
    _isApprovedOrOwner(msg.sender, _tokenId),
    'Transfer caller is not owner nor approved'
  );

  _transfer(_from, _to, _tokenId);
}

/**
 * @dev 토큰 소유자 또는 결제자 승인 여부 반환
 */
function _isApprovedOrOwner(address _spender, uint256 _tokenId)
  internal
  view
  returns (bool)
{
  address owner = this.ownerOf(_tokenId);

  return (_spender == owner || getApproved(_tokenId) == _spender);
}

/**
 * @dev 승인 여부 가져오기
 */
function getApproved(uint256 _tokenId) public view returns (address) {
  require(_exists(_tokenId), 'Operator query for nonexistent token');

  return _approvals[_tokenId];
}
/**
 * @dev 토큰ID의 소유자 여부 반환
 */
function _exists(uint256 _tokenId) internal view returns (bool) {
  return productToOwner[_tokenId] != address(0);
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './ProductFactory.sol';

contract ProductOwnership is ProductFactory {
  event Transfer(address from, address to, uint256 tokenId);
  event Approval(address productToOwner, address to, uint256 tokenId);

  mapping(uint256 => address) private _approvals;

  /**
   * @dev 토큰 소유량 가져오기
   */
  function balanceOf(address _owner) public view virtual returns (uint256) {
    return ownerProductCount[_owner];
  }

  /**
   * @dev 토큰 소유자 가져오기
   */
  function ownerOf(uint256 _tokenId) public view returns (address) {
    return productToOwner[_tokenId];
  }

  /**
   * @dev 소유자 또는 승인 여부에 따른 토큰 전송
   */
  function transferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  ) external {
    require(
      _isApprovedOrOwner(msg.sender, _tokenId),
      'Transfer caller is not owner nor approved'
    );

    _transfer(_from, _to, _tokenId);
  }

  /**
   * @dev 소유자가 토큰 승인하기
   */
  function approve(address _to, uint256 _tokenId) public {
    address owner = this.ownerOf(_tokenId);

    require(_to != owner, 'Approval to current owner');
    require(
      msg.sender == owner,
      'Approve caller is not owner nor approved for all'
    );

    _approve(_to, _tokenId);
  }

  /**
   * @dev 승인 여부 가져오기
   */
  function getApproved(uint256 _tokenId) public view returns (address) {
    require(_exists(_tokenId), 'Operator query for nonexistent token');

    return _approvals[_tokenId];
  }

  /**
   * @dev 토큰 전송
   */
  function _transfer(
    address _from,
    address _to,
    uint256 _tokenId
  ) private {
    ownerProductCount[_from]--;
    ownerProductCount[_to]++;

    productToOwner[_tokenId] = _to;

    emit Transfer(_from, _to, _tokenId);
  }

  /**
   * @dev 토큰 승인
   */
  function _approve(address _to, uint256 _tokenId) private {
    _approvals[_tokenId] = _to;

    emit Approval(this.ownerOf(_tokenId), _to, _tokenId);
  }

  /**
   * @dev 토큰 소유자 또는 결제자 승인 여부 반환
   */
  function _isApprovedOrOwner(address _spender, uint256 _tokenId)
    internal
    view
    returns (bool)
  {
    address owner = this.ownerOf(_tokenId);

    return (_spender == owner || getApproved(_tokenId) == _spender);
  }

  /**
   * @dev 토큰ID의 소유자 여부 반환
   */
  function _exists(uint256 _tokenId) internal view returns (bool) {
    return productToOwner[_tokenId] != address(0);
  }
}

const { expect } = require('chai');
const { ethers } = require('hardhat');

describe('ProductOwnership', async function () {
  let owner, user, spender;
  let productOwnership;
  let newProductEvents = [],
    newProductId;

  const product = [
    'MacBook-pro M1X 16inch',
    'apple',
    'MacBook-pro M1X 16inch, Space Gray, 64GB Memory, 8TB SSD Storage, Pre-Installed "Final Cut Pro" and "Logic Pro"',
    'https://store.storeimages.cdn-apple.com/8756/as-images.apple.com/is/mbp16-spacegray-gallery2-202110?wid=4000&hei=3072&fmt=jpeg&qlt=80&.v=1632799174000',
  ];

  before(async function () {
    const [ownerSigner, addrSigner, addr2Signer] = await ethers.getSigners();
    owner = ownerSigner;
    user = addrSigner;
    spender = addr2Signer;

    const Ownership = await ethers.getContractFactory('ProductOwnership');
    const ownership = await Ownership.deploy();

    await ownership.deployed();

    productOwnership = ownership;
  });

  it('#1 상품 생성하기', async function () {
    const createProduct = await productOwnership
      .connect(user)
      .createProduct(...product);

    const receipt = await createProduct.wait();

    const events = receipt.events.filter((x) => {
      return x.event == 'NewProduct';
    });
    newProductEvents = events;

    expect(events).to.not.length(0);
  });

  it('#2 추가된 상품 조회하기', async function () {
    const lastEvent = newProductEvents.pop();
    const productId = lastEvent.args.id.toNumber();
    newProductId = productId;

    const [...hot] = await productOwnership.getProduct(productId);

    expect(hot).deep.to.equal(product);
  });

  it('#3 Ownable 체크', async function () {
    const balanceOf = await productOwnership.balanceOf(user.address);
    const ownerOf = await productOwnership.ownerOf(newProductId);

    expect(balanceOf.toNumber()).to.equal(1);
    expect(ownerOf).to.equal(user.address);
  });

  it('#4 토큰 승인', async function () {
    await productOwnership.connect(user).approve(spender.address, newProductId);

    const approved = await productOwnership.getApproved(newProductId);

    expect(approved).to.equal(spender.address);
  });

  it('#5 승인 토큰 전송', async function () {
    await productOwnership.connect(user).transferFrom(
      user.address,
      spender.address,
      newProductId,
    );

    const productToOwner = await productOwnership.ownerOf(newProductId);
    expect(productToOwner).to.equal(spender.address);
  });
});

contract Escrow {
	// 아래부터 판매자주소, 토큰ID, 거래금액, 상태를 구조체(strcut)로 정의
	struct Trade {
    address poster;
    uint256 tokenId;
    uint256 amount;
    bytes32 status; // open, executed, confirmed, cancelled
  }

	// 매핑하여 여러 값을 상태변수로 저장
	mapping(uint256 => Trade) public trades;
}

	/**
   * @dev 거래 생성
   */
  function openTrade(uint256 _tokenId, uint256 _amount) external {
		// 컨트랙트에서 다른 컨트랙트 메서드 호출하기
    product.transferFrom(msg.sender, address(this), _tokenId);

    uint256 tradeId = tradeCounter;

    trades[tradeId] = Trade({
      poster: msg.sender,
      tokenId: _tokenId,
      amount: _amount,
      status: 'open'
    });

    tradeCounter++;

    emit TradeStatusChange(tradeId, 'open');
  }

// 컨트랙트에서 다른 컨트랙트 메서드 호출하기
product.transferFrom(msg.sender, address(this), _tokenId);

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IProductOwnership {
  event Transfer(
    address indexed from,
    address indexed to,
    uint256 indexed tokenId
  );
  event Approval(
    address indexed productToOwner,
    address indexed to,
    uint256 indexed tokenId
  );

  function balanceOf(address _owner) external view returns (uint256);

  function ownerOf(uint256 _tokenId) external view returns (address);

	// 사용할 함수 선언
	// 호출할 함수의 정보가 필요하기 때문에 해당 함수의 선언과 정확히 맞아야 한다.
  function transferFrom(
    address _from,
    address _to,
    uint256 _tokenId
  ) external;

  function approve(address _to, uint256 _tokenId) external;

  function getApproved(uint256 _tokenId) external view returns (address);
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './IProductOwnership.sol';

contract Escrow {
	// 컨트랙트 소유자 주소
	address private _owner;
  // 상태 변수로 선언하여 사용한다.
  IProductOwnership public product;

  // 수정자(modifier)는 기존 함수의 동작을 변경한다.
  modifier onlyOwner() {
    require(_owner == msg.sender, 'Caller is not the owner');
    _;
  }

  constructor(address _productAddress) {
		// 컨트랙트 소유자 설정
		_owner = msg.sender;
    // 배포 시 컨트랙트 주소가 잘못되거나 변경되는 것을 사전에 방지하기 위해
    // 외부 접근이 가능한 함수로 만들어 주소를 변경할 수 있도록 한다.
    setProductOwnership(_productAddress);
  }

  /**
   * @dev ProductOwnership 컨트랙트 주소 변경
   */
  function setProductOwnership(address _productAddress) public onlyOwner {
    // 인터페이스에 호출할 컨트랙트의 주소를 대입하여 초기화한다.
    product = IProductOwnership(_productAddress);
  }
}

/**
 * @dev 거래 구매
 * payable 속성 사용
 */
function executeTrade(uint256 _tradeId) external payable {
  require(trades[_tradeId].status == 'open', 'Trade is not open');
	// 전송한 이더와 판매 상품 금액이 맞는지 검사
  require(
    trades[_tradeId].amount == msg.value,
    'Trade amount does not match.'
  );

  executedTradeToSpender[_tradeId] = msg.sender;
  trades[_tradeId].status = 'executed';

  emit TradeStatusChange(_tradeId, 'executed');
}

/**
 * @dev 거래 확인
 */
function confirmTrade(uint256 _tradeId) external {
  require(trades[_tradeId].status == 'executed', 'Trade is not excuted');
  require(msg.sender == trades[_tradeId].poster, 'Caller is not the poster');

  product.transferFrom(
    address(this),
    executedTradeToSpender[_tradeId],
    trades[_tradeId].tokenId
  );

	// payable로 지정된 사용자 주소로 이더를 전송(transfer)
  payable(trades[_tradeId].poster).transfer(trades[_tradeId].amount);

  trades[_tradeId].status = 'confirmed';

  emit TradeStatusChange(_tradeId, 'confirmed');
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './IProductOwnership.sol';
import 'hardhat/console.sol';

contract Escrow {
  event TradeStatusChange(uint256 tradeId, string status);

  event BreakApproval(uint256 tradeId, address spender);

  event BreakTrade(uint256 tradeId);

  // ----------------------------------------------------------------------

  struct Trade {
    address poster;
    uint256 tokenId;
    uint256 amount;
    bytes32 status; // open, executed, confirmed, cancelled
  }

  address private _owner;

  IProductOwnership public product;

  mapping(uint256 => Trade) public trades;
  mapping(uint256 => address) public executedTradeToSpender;
  uint256 public tradeCounter;

  mapping(uint256 => address) private _breakApprovals;

  // ----------------------------------------------------------------------

  modifier onlyOwner() {
    require(_owner == msg.sender, 'Caller is not the owner');
    _;
  }

  // ----------------------------------------------------------------------

  constructor(address _productAddress) {
    _owner = msg.sender;
    tradeCounter = 0;
    setProductOwnership(_productAddress);
  }

  /**
   * @dev 거래 생성
   */
  function openTrade(uint256 _tokenId, uint256 _amount) external {
    product.transferFrom(msg.sender, address(this), _tokenId);

    uint256 tradeId = tradeCounter;

    trades[tradeId] = Trade({
      poster: msg.sender,
      tokenId: _tokenId,
      amount: _amount,
      status: 'open'
    });

    tradeCounter++;

    emit TradeStatusChange(tradeId, 'open');
  }

  /**
   * @dev 거래 구매
   */
  function executeTrade(uint256 _tradeId) external payable {
    require(trades[_tradeId].status == 'open', 'Trade is not open');
    require(
      trades[_tradeId].amount == msg.value,
      'Trade amount does not match.'
    );

    executedTradeToSpender[_tradeId] = msg.sender;
    trades[_tradeId].status = 'executed';

    emit TradeStatusChange(_tradeId, 'executed');
  }

  /**
   * @dev 거래 확인
   */
  function confirmTrade(uint256 _tradeId) external {
    require(trades[_tradeId].status == 'executed', 'Trade is not excuted');
    require(msg.sender == trades[_tradeId].poster, 'Caller is not the poster');

    product.transferFrom(
      address(this),
      executedTradeToSpender[_tradeId],
      trades[_tradeId].tokenId
    );

    payable(trades[_tradeId].poster).transfer(trades[_tradeId].amount);

    trades[_tradeId].status = 'confirmed';

    emit TradeStatusChange(_tradeId, 'confirmed');
  }

  /**
   * @dev 거래 파기
   */
  function breakTrade(uint256 _tradeId) external {
    require(trades[_tradeId].status == 'executed', 'Trade is not excuted');
    require(
      msg.sender == executedTradeToSpender[_tradeId],
      'Caller is not the spender'
    );
    require(msg.sender == _breakApprovals[_tradeId], 'Caller is not approved');

    payable(executedTradeToSpender[_tradeId]).transfer(trades[_tradeId].amount);

    executedTradeToSpender[_tradeId] = address(0);
    trades[_tradeId].status = 'open';

    emit BreakTrade(_tradeId);
    emit TradeStatusChange(_tradeId, 'open');
  }

  /**
   * @dev 거래 파기 승인
   */
  function approveBreak(uint256 _tradeId, address _spender) public {
    require(
      msg.sender == _owner || msg.sender == trades[_tradeId].poster,
      'Caller is not the poster or owner'
    );

    _breakApprovals[_tradeId] = _spender;

    emit BreakApproval(_tradeId, _spender);
  }

  /**
   * @dev 거래 등록 취소
   */
  function cancelTrade(uint256 _tradeId) external {
    require(trades[_tradeId].status == 'open', 'Trade is not open');
    require(msg.sender == trades[_tradeId].poster, 'Caller is not the poster');

    product.transferFrom(address(this), msg.sender, trades[_tradeId].tokenId);

    trades[_tradeId].status = 'cancelled';

    emit TradeStatusChange(_tradeId, 'cancelled');
  }

  // ----------------------------------------------------------------------

  /**
   * @dev ProductOwnership 컨트랙트 주소 변경
   */
  function setProductOwnership(address _productAddress) public onlyOwner {
    product = IProductOwnership(_productAddress);
  }

  /**
   * @dev 컨트랙트 소유자 변경
   */
  function changeOwner(address _newOwner) external onlyOwner {
    _owner = _newOwner;
  }
}