Stop Vibing. Start Building Onchain.

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18; // This is the solidity version we are using ( // these two line allows us to make a comment in our code)

// Basic Types: boolean, uint, int, address, bytes

contract SimpleStorage {

    // If you create a variable outside of a function which is then global is automatically assigned to a storage variable that is why we just call memeory
    // In the add Person function for the string vs calldata by default with no visablity type it's internal
    uint256 myFavoriteNumber; // No value set so it will = 0 this is technically a global variable it's declared outside a function

    // This is an global array in Solidity
    uint256[] listOfFavoriteNumbers; // global variable no values yet so default is = 0

    // Person public myFriend = Person({favoriteNumber: 7, name: "Bob"}); Not the way to do it cuz this is fixed data and you may have many friends

    // We will create an array of the people in this case our friends
    // Example if you added a 3 in the array then this would be a static arrary which can now only have a maximum size of 3 arrays
    // Person[3] public listOfPeople // This is a static array
    Person[] public listOfPeople; // Which again this is a global dynamic variable default = [] blank array

    // Right now we can add many friends to our listOfPeople of people array but if we had to call the retrieve to find out lets
    // say BOBS favorite number we would ahve to type 0,1,2 or 3 indexing to find t hat well there is so there has to be a better way
    // We will use mapping  type in solidity using keys similar to a dictionary
    mapping(string => uint256) public nameToFavoriteNumber;

    // uint256[] listOffavoriteNumbers; we can create our own types in solidity by using a struct
    struct Person{
        uint256 favoriteNumber;
        string name;
    }

    // This function chnages the state of the contarct globa variable so it requires a transaction whicj cost gas
    function store(uint256 _favoriteNumber) public {
        myFavoriteNumber = _favoriteNumber;
    }

    // A function marked view or pure does not need to change the state of the contract so it does not need to send a transaction
    // View reads from the state of the global variable myFavoriteNumber
    // Returns keyword after view will return the value of the function.
    function retrieve() public view returns(uint256) {
        return myFavoriteNumber;
    }

    // Understanding memory within solidity on EVM, calldata memory and storage
    // calldata and memory are temp they will only exist for the function of the call the one time we call the function
    // Now we need to create a function that will allow us to add people our friends to the listOfPeople of people array
    // The difference between calldata and memory variable can be changed can be manipulated
    // If you pass a temp calldata variable it can not modified
    // Storage is permanent variables that can be modified
    // Strings is memory of bytes
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        // Now here we will add a push function so we can push a new person into the listOfPeople array
        listOfPeople.push(Person(_favoriteNumber, _name));
        // Now in this addPerson function we will also add the person to our mapping
        nameToFavoriteNumber[_name] = _favoriteNumber;
    }

}