Goroutine + channel execution order

I'm new to golang and want to understand deeply how channel works.
In the past I've made a basic multithreaded program with .net so I kinda now what goroutine is

I assume that goroutine is some kind of thread (actually a green thread) that will run concurrently with other goroutine so there's no guarantee for the execution order

but what I don't understand when you combine goroutine and channel

I know that you can use channel to guarantee the execution order of goroutine because it can block goroutine

Lets say I have a code like this

func greet(c chan string) {

    fmt.Println("Before print 1st item")
    fmt.Println("Hello", <-c)
    fmt.Println("After print 1st item")

    fmt.Println("Before print 2nd item")
    fmt.Println("Hello", <-c)
    fmt.Println("After print 2nd  item")

}

func main() {
    fmt.Println("Main start")
    c := make(chan string)

     go greet(c)

    fmt.Println("Before insert 1st item")
    c <- "Alpha" // main goroutine blocked here and will be switched to another goroutine. Blocked because the channel is full or maybe I'm wrong here?
    fmt.Println("After insert 1st item")

    fmt.Println("Before insert 2nd item")
    c <- "Zebra" // why is it not blocked here ?
    fmt.Println("After insert 2nd item")

    time.Sleep(2 * time.Second)
    fmt.Println("Main end")
}

//Output
Main start
Before insert 1st item
Before print 1st item
Hello Alpha
After print 1st item
Before print 2nd item
After insert 1st item
Before insert 2nd item
After insert 2nd item // why is it printed here ???
Hello Zebra
After print 2nd  item
Main end

Why is it printed like that ???

// My expectation
Main start
Before insert 1st item
Before print 1st item
Hello Alpha
After print 1st item
Before print 2nd item
After insert 1st item
Before insert 2nd item
Hello Zebra
After print 2nd  item
After insert 2nd item 
Main end

KeyPoint from what I understand

1. The main gouroutine blocked on this line c <- "Alpha" so it switched to greet goroutine
2. The greet goroutine will continue to execute until it blocked on the second fmt.Println("Hello", <-c)
3. Now greet goroutine is blocked and the main goroutine is not blocked because the string Alpha in channel already read and it will continue to execute

My question is why main goroutine is not blocked on this line c <- "Zebra" ?

I expected it to be blocked again just like in step 2 and will switch to greet goroutine

Based on this doc
> By default, sends and receives block until the other side is ready. This allows goroutines to synchronize without explicit locks or condition variables.

Let's say channels are like a table. When somebody waits to receive from it, it is like you want to take something from the table. If there is anything, you take it and go, if there is nothing, you must wait for someone to put it over there. Same happens when you want to send at the channel. If there is nothing over the table, you just put the thing you have and leave, if there is something on it, you must wait for someone to take it to put your thing. (remember you can have a channel with space for more that one thing).

At the moment you get liberated, you keep doing whatever you want, no need to wait or syncronize. So you can't know what will happen before, because depending on the processing cycles you have been assigned you will get there before or after the other routines.

If you launch that a few times, you will see that different output appears.