CampaignInfo

contract CampaignInfo is
    ICampaignData,
    ICampaignInfo,
    Ownable,
    PausableCancellable,
    TimestampChecker,
    AdminAccessChecker,
    Initializable
{
    CampaignData private s_campaignData;
    mapping(bytes32 => address) private s_platformTreasuryAddress;
    mapping(bytes32 => uint256) private s_platformFeePercent;
    mapping(bytes32 => bool) private s_isSelectedPlatform;
    mapping(bytes32 => bool) private s_isApprovedPlatform;
    mapping(bytes32 => bytes32) private s_platformData;
    bytes32[] private s_approvedPlatformHashes;
}

constructor(address creator) Ownable(creator);

function initialize(
    address creator,
    IGlobalParams globalParams,
    bytes32[] calldata selectedPlatformHash,
    bytes32[] calldata platformDataKey,
    bytes32[] calldata platformDataValue,
    CampaignData calldata campaignData
) external initializer;

function getCampaignConfig() public view returns (Config memory config);

function getLaunchTime() public view override returns (uint256);

function getDeadline() public view override returns (uint256);

function getGoalAmount() external view override returns (uint256);

function getTokenAddress() external view override returns (address);

function getProtocolFeePercent() external view override returns (uint256);

function getIdentifierHash() external view override returns (bytes32);

function checkIfPlatformSelected(bytes32 platformHash) public view override returns (bool);

function checkIfPlatformApproved(bytes32 platformHash) public view returns (bool);

function getApprovedPlatformHashes() external view returns (bytes32[] memory);

function getPlatformAdminAddress(bytes32 platformHash) external view override returns (address);

function getPlatformFeePercent(bytes32 platformHash) external view override returns (uint256);

function getPlatformData(bytes32 platformDataKey) external view override returns (bytes32);

function updateLaunchTime(uint256 launchTime)
    external
    override
    onlyOwner
    currentTimeIsLess(getLaunchTime())
    whenNotPaused
    whenNotCancelled;

function updateDeadline(uint256 deadline)
    external
    override
    onlyOwner
    currentTimeIsLess(getLaunchTime())
    whenNotPaused
    whenNotCancelled;

function updateGoalAmount(uint256 goalAmount)
    external
    override
    onlyOwner
    currentTimeIsLess(getLaunchTime())
    whenNotPaused
    whenNotCancelled;

function updateSelectedPlatform(bytes32 platformHash, bool selection)
    external
    override
    onlyOwner
    currentTimeIsLess(getLaunchTime())
    whenNotPaused
    whenNotCancelled;

function owner() public view override(ICampaignInfo, Ownable) returns (address account);

function transferOwnership(address newOwner)
    public
    override(ICampaignInfo, Ownable)
    onlyOwner
    whenNotPaused
    whenNotCancelled;

function getProtocolAdminAddress() public view override returns (address);

function paused() public view override(ICampaignInfo, PausableCancellable) returns (bool);

function cancelled() public view override(ICampaignInfo, PausableCancellable) returns (bool);

function _pauseCampaign(bytes32 message) external onlyProtocolAdmin;

function _unpauseCampaign(bytes32 message) external onlyProtocolAdmin;

function _cancelCampaign(bytes32 message) external;

function _setPlatformInfo(bytes32 platformHash, address platformTreasuryAddress) external whenNotPaused;

event CampaignInfoLaunchTimeUpdated(uint256 newLaunchTime);

event CampaignInfoDeadlineUpdated(uint256 newDeadline);

event CampaignInfoGoalAmountUpdated(uint256 newGoalAmount);

event CampaignInfoSelectedPlatformUpdated(bytes32 indexed platformHash, bool selection);

event CampaignInfoPlatformInfoUpdated(bytes32 indexed platformHash, address indexed platformTreasury);

error CampaignInfoInvalidPlatformUpdate(bytes32 platformHash, bool selection);

error CampaignInfoUnauthorized();

error CampaignInfoInvalidInput();

error CampaignInfoPlatformNotSelected(bytes32 platformHash);

error CampaignInfoPlatformAlreadyApproved(bytes32 platformHash);

struct CampaignData {
    uint256 launchTime;    // Campaign launch timestamp
    uint256 deadline;      // Campaign end timestamp
    uint256 goalAmount;    // Target funding amount
}

struct Config {
    address treasuryFactory;     // Treasury factory address
    address token;               // Campaign token address
    uint256 protocolFeePercent;  // Protocol fee percentage
    bytes32 identifierHash;      // Unique campaign identifier
}

// Get campaign configuration
const config = await campaignInfo.getCampaignConfig();
console.log('Treasury Factory:', config.treasuryFactory);
console.log('Token:', config.token);
console.log('Protocol Fee:', config.protocolFeePercent);

// Get campaign timeline
const launchTime = await campaignInfo.getLaunchTime();
const deadline = await campaignInfo.getDeadline();
console.log('Launch:', new Date(launchTime.toNumber() * 1000));
console.log('Ends:', new Date(deadline.toNumber() * 1000));

// Check campaign state
const isPaused = await campaignInfo.paused();
const isCancelled = await campaignInfo.cancelled();
console.log('Paused:', isPaused, 'Cancelled:', isCancelled);

// Update launch time (only before launch)
const newLaunchTime = Math.floor(Date.now() / 1000) + 86400; // 1 day from now
const tx = await campaignInfo.updateLaunchTime(newLaunchTime);
await tx.wait();

// Update deadline
const newDeadline = Math.floor(Date.now() / 1000) + 2592000; // 30 days
const tx2 = await campaignInfo.updateDeadline(newDeadline);
await tx2.wait();

// Update goal amount
const newGoal = ethers.utils.parseEther('20000');
const tx3 = await campaignInfo.updateGoalAmount(newGoal);
await tx3.wait();

// Get all approved platforms
const approvedPlatforms = await campaignInfo.getApprovedPlatformHashes();
console.log('Approved platforms:', approvedPlatforms);

// Check platform status
const platformHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes('my-platform'));
const isSelected = await campaignInfo.checkIfPlatformSelected(platformHash);
const isApproved = await campaignInfo.checkIfPlatformApproved(platformHash);

// Get platform configuration
const platformAdmin = await campaignInfo.getPlatformAdminAddress(platformHash);
const platformFee = await campaignInfo.getPlatformFeePercent(platformHash);
const platformTreasury = await campaignInfo.getPlatformTreasuryAddress(platformHash);

// Update platform selection
const tx = await campaignInfo.updateSelectedPlatform(platformHash, true);
await tx.wait();

// Campaign is created by factory
const factory = await ethers.getContractAt('CampaignInfoFactory', factoryAddress);
const tx = await factory.createCampaign(campaignData);
const receipt = await tx.wait();

// Extract campaign address from event
const campaignAddress = receipt.events.find(e => 
  e.event === 'CampaignInfoFactoryCampaignCreated'
).args.campaignAddress;

// Connect to campaign
const campaign = await ethers.getContractAt('CampaignInfo', campaignAddress);

// Get platform treasury address
const treasuryAddress = await campaign.getPlatformTreasuryAddress(platformHash);

// Connect to treasury
const treasury = await ethers.getContractAt('AllOrNothing', treasuryAddress);

// Check campaign state before operations
const isPaused = await campaign.paused();
const isCancelled = await campaign.cancelled();

if (isPaused || isCancelled) {
  throw new Error('Campaign is not active');
}