// 프로젝트 생성 후 기본 구조
MyMauiApp/
├── Platforms/
│   ├── Android/
│   ├── iOS/
│   ├── MacCatalyst/
│   └── Windows/
├── Resources/
│   ├── Images/
│   ├── Fonts/
│   └── Styles/
├── App.xaml
├── AppShell.xaml
└── MainPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.MainPage">

    <ScrollView>
        <VerticalStackLayout 
            Spacing="25" 
            Padding="30,0"
            VerticalOptions="Center">

            <Label 
                Text="안녕하세요! MAUI 세계에 오신 걸 환영해요! 🎉"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="32"
                HorizontalOptions="Center" />

            <Button 
                x:Name="CounterBtn"
                Text="클릭해보세요!"
                Clicked="OnCounterClicked"
                HorizontalOptions="Center" />

        </VerticalStackLayout>
    </ScrollView>

</ContentPage>

namespace MyMauiApp;

public partial class MainPage : ContentPage
{
    int count = 0;

    public MainPage()
    {
        InitializeComponent();
    }

    private void OnCounterClicked(object sender, EventArgs e)
    {
        count++;

        if (count == 1)
            CounterBtn.Text = $"1번 클릭했어요!";
        else
            CounterBtn.Text = $"{count}번 클릭했어요!";

        SemanticScreenReader.Announce(CounterBtn.Text);
    }
}

// Model/TodoItem.cs
public class TodoItem
{
    public string Title { get; set; }
    public bool IsCompleted { get; set; }
    public DateTime CreatedAt { get; set; }
}

// ViewModel/TodoViewModel.cs
using System.Collections.ObjectModel;
using System.Windows.Input;

public class TodoViewModel : INotifyPropertyChanged
{
    public ObservableCollection<TodoItem> TodoItems { get; set; }
    
    private string newTodoText;
    public string NewTodoText
    {
        get => newTodoText;
        set
        {
            newTodoText = value;
            OnPropertyChanged(nameof(NewTodoText));
        }
    }

    public ICommand AddTodoCommand { get; }

    public TodoViewModel()
    {
        TodoItems = new ObservableCollection<TodoItem>();
        AddTodoCommand = new Command(AddTodo);
    }

    private void AddTodo()
    {
        if (!string.IsNullOrWhiteSpace(NewTodoText))
        {
            TodoItems.Add(new TodoItem
            {
                Title = NewTodoText,
                IsCompleted = false,
                CreatedAt = DateTime.Now
            });
            NewTodoText = string.Empty;
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, 
            new PropertyChangedEventArgs(propertyName));
    }
}

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             x:Class="TodoApp.Views.TodoPage">
    
    <ContentPage.BindingContext>
        <viewmodels:TodoViewModel />
    </ContentPage.BindingContext>

    <VerticalStackLayout Padding="20">
        
        <HorizontalStackLayout Spacing="10">
            <Entry Text="{Binding NewTodoText}" 
                   Placeholder="새로운 할 일을 입력하세요"
                   HorizontalOptions="FillAndExpand" />
            <Button Text="추가" 
                    Command="{Binding AddTodoCommand}" />
        </HorizontalStackLayout>

        <CollectionView ItemsSource="{Binding TodoItems}">
            <CollectionView.ItemTemplate>
                <DataTemplate>
                    <HorizontalStackLayout Padding="10">
                        <CheckBox IsChecked="{Binding IsCompleted}" />
                        <Label Text="{Binding Title}" 
                               VerticalOptions="Center" />
                    </HorizontalStackLayout>
                </DataTemplate>
            </CollectionView.ItemTemplate>
        </CollectionView>

    </VerticalStackLayout>

</ContentPage>

<Shell xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
       xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
       xmlns:local="clr-namespace:MyApp.Views"
       x:Class="MyApp.AppShell">

    <!-- 탭 바 구조 -->
    <TabBar>
        <ShellContent Title="홈" 
                      Icon="home.png"
                      ContentTemplate="{DataTemplate local:HomePage}" />
        
        <ShellContent Title="검색" 
                      Icon="search.png"
                      ContentTemplate="{DataTemplate local:SearchPage}" />
        
        <ShellContent Title="프로필" 
                      Icon="profile.png"
                      ContentTemplate="{DataTemplate local:ProfilePage}" />
    </TabBar>

</Shell>

// 먼저 라우트를 등록해요
Routing.RegisterRoute("detailpage", typeof(DetailPage));

// 그리고 이동!
await Shell.Current.GoToAsync("detailpage");

// 파라미터도 전달할 수 있어요
await Shell.Current.GoToAsync($"detailpage?id={itemId}");

// 뒤로 가기
await Shell.Current.GoToAsync("..");

[QueryProperty(nameof(ItemId), "id")]
public partial class DetailPage : ContentPage
{
    private string itemId;
    public string ItemId
    {
        get => itemId;
        set
        {
            itemId = value;
            LoadItemDetails(value);
        }
    }

    private async void LoadItemDetails(string id)
    {
        // ID로 상세 정보를 불러와요
        var item = await DataService.GetItemAsync(id);
        BindingContext = item;
    }
}

public void DoSomethingPlatformSpecific()
{
#if ANDROID
    // Android 전용 코드
    Android.Widget.Toast.MakeText(
        Platform.CurrentActivity, 
        "안드로이드에서 실행 중!", 
        Android.Widget.ToastLength.Short
    ).Show();
#elif IOS
    // iOS 전용 코드
    var alert = UIAlertController.Create(
        "알림", 
        "iOS에서 실행 중!", 
        UIAlertControllerStyle.Alert
    );
    // ... alert 표시 코드
#elif WINDOWS
    // Windows 전용 코드
    var dialog = new Windows.UI.Popups.MessageDialog(
        "윈도우에서 실행 중!"
    );
    await dialog.ShowAsync();
#endif
}

// 공통 인터페이스
public interface INotificationService
{
    void ShowNotification(string title, string message);
}

// Android 구현 (Platforms/Android 폴더에)
public class NotificationService : INotificationService
{
    public void ShowNotification(string title, string message)
    {
        // Android 알림 구현
        var builder = new NotificationCompat.Builder(
            Platform.CurrentActivity, 
            "default"
        )
        .SetContentTitle(title)
        .SetContentText(message)
        .SetSmallIcon(Resource.Drawable.notification_icon);
        
        // 알림 표시
    }
}

// iOS 구현 (Platforms/iOS 폴더에)
public class NotificationService : INotificationService
{
    public void ShowNotification(string title, string message)
    {
        // iOS 알림 구현
        var content = new UNMutableNotificationContent
        {
            Title = title,
            Body = message
        };
        
        // 알림 표시
    }
}

// MauiProgram.cs에서 등록
builder.Services.AddSingleton<INotificationService, NotificationService>();

// 사용할 때
public class MyViewModel
{
    private readonly INotificationService notificationService;
    
    public MyViewModel(INotificationService notificationService)
    {
        this.notificationService = notificationService;
    }
    
    public void SendNotification()
    {
        notificationService.ShowNotification(
            "새 메시지", 
            "안녕하세요!"
        );
    }
}

<Application xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             x:Class="MyApp.App">
    <Application.Resources>
        <ResourceDictionary>
            
            <!-- 색상 정의 -->
            <Color x:Key="PrimaryColor">#6200EE</Color>
            <Color x:Key="SecondaryColor">#03DAC6</Color>
            <Color x:Key="BackgroundColor">#FFFFFF</Color>
            <Color x:Key="TextColor">#000000</Color>
            
            <!-- 스타일 정의 -->
            <Style TargetType="Button">
                <Setter Property="BackgroundColor" 
                        Value="{StaticResource PrimaryColor}" />
                <Setter Property="TextColor" 
                        Value="White" />
                <Setter Property="CornerRadius" 
                        Value="8" />
                <Setter Property="Padding" 
                        Value="16,8" />
            </Style>
            
            <Style x:Key="TitleLabel" TargetType="Label">
                <Setter Property="FontSize" Value="24" />
                <Setter Property="FontAttributes" Value="Bold" />
                <Setter Property="TextColor" 
                        Value="{StaticResource PrimaryColor}" />
            </Style>
            
        </ResourceDictionary>
    </Application.Resources>
</Application>

<Label Text="제목입니다" Style="{StaticResource TitleLabel}" />
<Button Text="클릭하세요" /> <!-- 자동으로 스타일 적용 -->

<Application.Resources>
    <ResourceDictionary>
        
        <!-- 라이트 테마 -->
        <Color x:Key="PageBackgroundColor">White</Color>
        <Color x:Key="TextColor">Black</Color>
        
        <!-- 다크 테마 (AppThemeBinding 사용) -->
        <Style TargetType="ContentPage" ApplyToDerivedTypes="True">
            <Setter Property="BackgroundColor" 
                    Value="{AppThemeBinding Light=White, Dark=#1E1E1E}" />
        </Style>
        
        <Style TargetType="Label">
            <Setter Property="TextColor" 
                    Value="{AppThemeBinding Light=Black, Dark=White}" />
        </Style>
        
    </ResourceDictionary>
</Application.Resources>

// 현재 테마 확인
var currentTheme = Application.Current.RequestedTheme;

// 테마 변경
Application.Current.UserAppTheme = AppTheme.Dark;

// 저장하기
Preferences.Set("username", "홍길동");
Preferences.Set("is_logged_in", true);
Preferences.Set("font_size", 16);

// 불러오기
string username = Preferences.Get("username", "기본값");
bool isLoggedIn = Preferences.Get("is_logged_in", false);
int fontSize = Preferences.Get("font_size", 14);

// 삭제하기
Preferences.Remove("username");

// 전체 삭제
Preferences.Clear();

// 저장하기
await SecureStorage.SetAsync("oauth_token", "abc123xyz");

// 불러오기
string token = await SecureStorage.GetAsync("oauth_token");

// 삭제하기
SecureStorage.Remove("oauth_token");

// 모델 정의
public class TodoItem
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }
    
    public string Title { get; set; }
    public bool IsCompleted { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 데이터베이스 서비스
public class TodoDatabase
{
    private SQLiteAsyncConnection database;

    public TodoDatabase(string dbPath)
    {
        database = new SQLiteAsyncConnection(dbPath);
        database.CreateTableAsync<TodoItem>().Wait();
    }

    // 전체 조회
    public Task<List<TodoItem>> GetItemsAsync()
    {
        return database.Table<TodoItem>().ToListAsync();
    }

    // 단일 조회
    public Task<TodoItem> GetItemAsync(int id)
    {
        return database.Table<TodoItem>()
                      .Where(i => i.Id == id)
                      .FirstOrDefaultAsync();
    }

    // 저장
    public Task<int> SaveItemAsync(TodoItem item)
    {
        if (item.Id != 0)
            return database.UpdateAsync(item);
        else
            return database.InsertAsync(item);
    }

    // 삭제
    public Task<int> DeleteItemAsync(TodoItem item)
    {
        return database.DeleteAsync(item);
    }
}

// 사용하기
var dbPath = Path.Combine(
    FileSystem.AppDataDirectory, 
    "todos.db3"
);
var database = new TodoDatabase(dbPath);

// 데이터 추가
await database.SaveItemAsync(new TodoItem
{
    Title = "MAUI 공부하기",
    IsCompleted = false,
    CreatedAt = DateTime.Now
});

// 데이터 조회
var items = await database.GetItemsAsync();

public class ApiService
{
    private readonly HttpClient httpClient;
    private const string BaseUrl = "https://api.example.com";

    public ApiService()
    {
        httpClient = new HttpClient
        {
            BaseAddress = new Uri(BaseUrl)
        };
    }

    // GET 요청
    public async Task<List<Product>> GetProductsAsync()
    {
        try
        {
            var response = await httpClient.GetAsync("/products");
            response.EnsureSuccessStatusCode();
            
            var json = await response.Content.ReadAsStringAsync();
            var products = JsonSerializer.Deserialize<List<Product>>(json);
            
            return products;
        }
        catch (Exception ex)
        {
            // 에러 처리
            Debug.WriteLine($"Error: {ex.Message}");
            return new List<Product>();
        }
    }

    // POST 요청
    public async Task<bool> CreateProductAsync(Product product)
    {
        try
        {
            var json = JsonSerializer.Serialize(product);
            var content = new StringContent(
                json, 
                Encoding.UTF8, 
                "application/json"
            );
            
            var response = await httpClient.PostAsync("/products", content);
            return response.IsSuccessStatusCode;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Error: {ex.Message}");
            return false;
        }
    }

    // 인증 토큰 추가
    public void SetAuthToken(string token)
    {
        httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", token);
    }
}

// API 인터페이스 정의
public interface IProductApi
{
    [Get("/products")]
    Task<List<Product>> GetProducts();

    [Get("/products/{id}")]
    Task<Product> GetProduct(int id);

    [Post("/products")]
    Task<Product> CreateProduct([Body] Product product);

    [Put("/products/{id}")]
    Task<Product> UpdateProduct(int id, [Body] Product product);

    [Delete("/products/{id}")]
    Task DeleteProduct(int id);
}

// 사용하기
var api = RestService.For<IProductApi>("https://api.example.com");
var products = await api.GetProducts();

public async Task<List<Product>> GetProductsAsync()
{
    // 연결 상태 확인
    if (Connectivity.NetworkAccess != NetworkAccess.Internet)
    {
        await App.Current.MainPage.DisplayAlert(
            "오류", 
            "인터넷 연결을 확인해주세요.", 
            "확인"
        );
        return new List<Product>();
    }

    // 네트워크 요청 진행
    var products = await apiService.GetProductsAsync();
    return products;
}

// 연결 상태 변화 감지
Connectivity.ConnectivityChanged += (sender, e) =>
{
    if (e.NetworkAccess == NetworkAccess.Internet)
    {
        Debug.WriteLine("인터넷 연결됨!");
    }
    else
    {
        Debug.WriteLine("인터넷 연결 끊김!");
    }
};

// 사진 찍기
public async Task<FileResult> TakePhotoAsync()
{
    try
    {
        var photo = await MediaPicker.CapturePhotoAsync();
        return photo;
    }
    catch (Exception ex)
    {
        Debug.WriteLine($"Error: {ex.Message}");
        return null;
    }
}

// 갤러리에서 선택
public async Task<FileResult> PickPhotoAsync()
{
    try
    {
        var photo = await MediaPicker.PickPhotoAsync(new MediaPickerOptions
        {
            Title = "사진을 선택하세요"
        });
        return photo;
    }
    catch (Exception ex)
    {
        Debug.WriteLine($"Error: {ex.Message}");
        return null;
    }
}

// 이미지 표시하기
var photo = await PickPhotoAsync();
if (photo != null)
{
    var stream = await photo.OpenReadAsync();
    MyImage.Source = ImageSource.FromStream(() => stream);
}

public async Task<Location> GetCurrentLocationAsync()
{
    try
    {
        var location = await Geolocation.GetLastKnownLocationAsync();
        
        if (location == null)
        {
            var request = new GeolocationRequest(
                GeolocationAccuracy.Medium, 
                TimeSpan.FromSeconds(10)
            );
            location = await Geolocation.GetLocationAsync(request);
        }

        if (location != null)
        {
            Debug.WriteLine($"위도: {location.Latitude}");
            Debug.WriteLine($"경도: {location.Longitude}");
        }

        return location;
    }
    catch (Exception ex)
    {
        Debug.WriteLine($"Error: {ex.Message}");
        return null;
    }
}

// 즉시 알림
await LocalNotificationCenter.Current.Show(new NotificationRequest
{
    NotificationId = 1,
    Title = "안녕하세요!",
    Description = "MAUI에서 보내는 알림이에요 😊",
    BadgeNumber = 1
});

// 예약 알림
await LocalNotificationCenter.Current.Show(new NotificationRequest
{
    NotificationId = 2,
    Title = "리마인더",
    Description = "30분 후에 회의가 있어요!",
    Schedule = new NotificationRequestSchedule
    {
        NotifyTime = DateTime.Now.AddMinutes(30)
    }
});

// 페이드 인/아웃
await MyLabel.FadeTo(0, 1000); // 1초 동안 투명하게
await MyLabel.FadeTo(1, 1000); // 1초 동안 불투명하게

// 크기 변화
await MyButton.ScaleTo(1.5, 500); // 0.5초 동안 1.5배 확대
await MyButton.ScaleTo(1, 500);   // 원래 크기로

// 회전
await MyImage.RotateTo(360, 2000); // 2초 동안 360도 회전

// 이동
await MyView.TranslateTo(100, 100, 1000); // 1초 동안 (100,100)으로 이동

// 복합 애니메이션
var animation = new Animation();
animation.Add(0, 0.5, new Animation(v => MyView.Scale = v, 1, 1.5));
animation.Add(0.5, 1, new Animation(v => MyView.Rotation = v, 0, 360));
animation.Commit(this, "ComplexAnimation", length: 2000);

// xUnit 사용 예시
public class TodoViewModelTests
{
    [Fact]
    public void AddTodo_ShouldAddItemToCollection()
    {
        // Arrange
        var viewModel = new TodoViewModel();
        viewModel.NewTodoText = "테스트 항목";

        // Act
        viewModel.AddTodoCommand.Execute(null);

        // Assert
        Assert.Single(viewModel.TodoItems);
        Assert.Equal("테스트 항목", viewModel.TodoItems[0].Title);
    }

    [Fact]
    public void AddTodo_WithEmptyText_ShouldNotAddItem()
    {
        // Arrange
        var viewModel = new TodoViewModel();
        viewModel.NewTodoText = "";

        // Act
        viewModel.AddTodoCommand.Execute(null);

        // Assert
        Assert.Empty(viewModel.TodoItems);
    }
}