package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

go run hello.go

// هذا تعليق من سطر واحد
fmt.Println("Hello, World!")

/*
هذا تعليق متعدد الأسطر
يمتد عبر عدة أسطر
*/

// إعلان نوع صريح
var name string = "John"
var age int = 25

// الاستدلال على النوع
name := "John"
age := 25

// إعلان متغيرات متعددة
var x, y int = 10, 20
x, y := 10, 20

// أنواع الأعداد الصحيحة
var age int = 25
var smallNumber int8 = 127
var largeNumber int64 = 9223372036854775807

// أنواع الأعداد العشرية
var temperature float32 = 36.5
var pi float64 = 3.14159265359

// الأعداد المركبة
var complexNum complex64 = 3 + 4i

// إعلان النصوص
var greeting string = "Hello, Go!"
name := "Alice"

// عمليات النصوص
fmt.Println(len(greeting))        // طول النص
fmt.Println(greeting[0])          // الوصول إلى الحرف الأول (بايت)
fmt.Println(greeting[0:5])        // تقطيع النص
fmt.Println(strings.ToUpper(name)) // التحويل إلى أحرف كبيرة

var isActive bool = true
var isComplete bool = false

// العمليات المنطقية
result1 := true && false  // false
result2 := true || false  // true
result3 := !true          // false

const Pi = 3.14159
const MaxUsers = 1000

// ثوابت متعددة
const (
    StatusOK = 200
    StatusNotFound = 404
    StatusError = 500
)

// ثوابت محددة النوع
const Version string = "1.0.0"

// إعلان المصفوفة
var numbers [5]int = [5]int{1, 2, 3, 4, 5}
names := [3]string{"Alice", "Bob", "Charlie"}

// الوصول إلى العناصر
fmt.Println(numbers[0])  // 1
numbers[0] = 10         // تعديل العنصر

// طول المصفوفة
fmt.Println(len(numbers)) // 5

// إعلان الشريحة
numbers := []int{1, 2, 3, 4, 5}
var emptySlice []int

// إنشاء شرائح من المصفوفات
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // [2, 3, 4]

// عمليات الشرائح
numbers = append(numbers, 6)      // إضافة عنصر
numbers = append(numbers, 7, 8, 9) // إضافة عناصر متعددة

// سعة الشريحة وطولها
fmt.Println(len(numbers)) // الطول: 9
fmt.Println(cap(numbers)) // السعة: 10 (قد تختلف)

// إعلان الخريطة
student := map[string]interface{}{
    "name": "John",
    "age":  20,
    "major": "Computer Science",
}

// إعلان بديل
var scores map[string]int = make(map[string]int)
scores["math"] = 95
scores["science"] = 88

// الوصول والتعديل
fmt.Println(student["name"])
student["age"] = 21
student["gpa"] = 3.8

// وصول آمن
if phone, exists := student["phone"]; exists {
    fmt.Println(phone)
} else {
    fmt.Println("Phone not provided")
}

// التكرار عبر الخريطة
for key, value := range student {
    fmt.Printf("%s: %v\n", key, value)
}

// تعريف الهيكل
type Person struct {
    Name string
    Age  int
    City string
}

// إنشاء مثيلات الهيكل
person1 := Person{"Alice", 25, "New York"}
person2 := Person{
    Name: "Bob",
    Age:  30,
    City: "London",
}

// الوصول إلى الحقول
fmt.Println(person1.Name)
person1.Age = 26

a, b := 10, 3

fmt.Printf("Addition: %d\n", a + b)      // 13
fmt.Printf("Subtraction: %d\n", a - b)   // 7
fmt.Printf("Multiplication: %d\n", a * b)  // 30
fmt.Printf("Division: %d\n", a / b)      // 3
fmt.Printf("Modulus: %d\n", a % b)      // 1

x, y := 5, 10

fmt.Printf("Equal: %t\n", x == y)     // false
fmt.Printf("Not equal: %t\n", x != y) // true
fmt.Printf("Greater than: %t\n", x > y)  // false
fmt.Printf("Less than: %t\n", x < y)  // true

a, b := true, false

fmt.Printf("AND operation: %t\n", a && b)  // false
fmt.Printf("OR operation: %t\n", a || b)    // true
fmt.Printf("NOT operation: %t\n", !a)    // false

age := 20
if age >= 18 {
    fmt.Println("Adult")
} else if age >= 13 {
    fmt.Println("Teen")
} else {
    fmt.Println("Child")
}

// if مع عبارة قصيرة
if score := 85; score >= 90 {
    fmt.Println("Grade: A")
} else if score >= 80 {
    fmt.Println("Grade: B")
} else {
    fmt.Println("Grade: C")
}

// حلقة for أساسية
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// حلقة على نمط while
count := 0
for count < 5 {
    fmt.Println(count)
    count++
}

// حلقة لا نهائية
for {
    fmt.Println("This will run forever")
    break // استخدم break للخروج
}

// حلقة range (للشرائح، المصفوفات، الخرائط)
fruits := []string{"apple", "banana", "cherry"}
for index, fruit := range fruits {
    fmt.Printf("%d: %s\n", index, fruit)
}

day := "Monday"
switch day {
case "Monday":
    fmt.Println("Start of the week")
case "Friday":
    fmt.Println("Weekend is near")
case "Saturday", "Sunday":
    fmt.Println("Weekend!")
default:
    fmt.Println("Regular day")
}

// Switch بدون تعبير
score := 85
switch {
case score >= 90:
    fmt.Println("Grade: A")
case score >= 80:
    fmt.Println("Grade: B")
case score >= 70:
    fmt.Println("Grade: C")
default:
    fmt.Println("Grade: F")
}

func greet(name string) string {
    return "Hello, " + name + "!"
}

// استدعاء الدالة
message := greet("John")
fmt.Println(message)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return a / b, nil
}

// استخدام قيم الإرجاع المتعددة
result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

func calculateRectangle(width, height float64) (area float64, perimeter float64) {
    area = width * height
    perimeter = 2 * (width + height)
    return // إرجاع عاري
}

area, perimeter := calculateRectangle(5, 3)
fmt.Printf("Area: %.2f, Perimeter: %.2f\n", area, perimeter)

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

fmt.Println(sum(1, 2, 3, 4))  // 10
fmt.Println(sum(5, 10, 15))   // 30

func modifyValue(x *int) {
    *x = *x * 2
}

func main() {
    value := 10
    fmt.Println("Before:", value) // 10

    modifyValue(&value)
    fmt.Println("After:", value)  // 20
}

type Rectangle struct {
    Width  float64
    Height float64
}

// طريقة بمستقبل قيمة
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// طريقة بمستقبل مؤشر
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rectangle{Width: 5, Height: 3}
fmt.Println("Area:", rect.Area()) // 15

rect.Scale(2)
fmt.Println("Scaled Area:", rect.Area()) // 60

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

func printShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

circle := Circle{Radius: 5}
printShapeInfo(circle)

func readFile(filename string) (string, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return "", fmt.Errorf("failed to read file %s: %w", filename, err)
    }
    return string(data), nil
}

content, err := readFile("example.txt")
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Content:", content)

func worker(id int) {
    for i := 0; i < 3; i++ {
        fmt.Printf("Worker %d: %d\n", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    // بدء عدة goroutines
    for i := 1; i <= 3; i++ {
        go worker(i)
    }

    // الانتظار حتى تكتمل goroutines
    time.Sleep(time.Second)
    fmt.Println("All workers completed")
}

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i // إرسال قيمة إلى القناة
        time.Sleep(time.Millisecond * 100)
    }
    close(ch) // إغلاق القناة عند الانتهاء
}

func consumer(ch <-chan int) {
    for value := range ch {
        fmt.Println("Received:", value)
    }
}

func main() {
    ch := make(chan int, 3) // قناة مخزنة

    go producer(ch)
    consumer(ch)

    fmt.Println("Channel communication completed")
}

// قراءة الملفات
data, err := os.ReadFile("example.txt")
if err != nil {
    fmt.Println("Error reading file:", err)
    return
}
fmt.Println("File content:", string(data))

// كتابة الملفات
content := "Hello, Go!\n"
err = os.WriteFile("output.txt", []byte(content), 0644)
if err != nil {
    fmt.Println("Error writing file:", err)
    return
}
fmt.Println("File written successfully")

// استيراد حزم المكتبة القياسية
import (
    "fmt"
    "math"
    "strings"
)

func main() {
    fmt.Println(math.Sqrt(16))        // 4
    fmt.Println(strings.ToUpper("go")) // GO
}

// في ملف math_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
    result := add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("add(2, 3) = %d; want %d", result, expected)
    }
}

func add(a, b int) int {
    return a + b
}