// internal/auth/handler/auth_handler.go
package handler

import (
    "net/http"
    
    "github.com/labstack/echo/v4"
    "github.com/your/project/internal/auth/dto"
    "github.com/your/project/internal/auth/service"
    "github.com/your/project/pkg/response"
)

type AuthHandler struct {
    authService service.AuthService
}

func NewAuthHandler(authService service.AuthService) *AuthHandler {
    return &AuthHandler{authService: authService}
}

func (h *AuthHandler) Login(c echo.Context) error {
    var req dto.LoginRequest
    if err := c.Bind(&req); err != nil {
        return response.Error(c, http.StatusBadRequest, "invalid request")
    }
    
    if err := c.Validate(&req); err != nil {
        return response.ValidationError(c, err)
    }
    
    token, err := h.authService.Login(c.Request().Context(), &req)
    if err != nil {
        return response.Error(c, http.StatusUnauthorized, err.Error())
    }
    
    return response.Success(c, http.StatusOK, token)
}

// internal/auth/service/auth_service.go
package service

import (
    "context"
    "errors"
    
    "github.com/your/project/internal/auth/dto"
    "github.com/your/project/internal/auth/repository"
    "github.com/your/project/pkg/hash"
    "github.com/your/project/pkg/jwt"
)

type AuthService interface {
    Login(ctx context.Context, req *dto.LoginRequest) (*dto.TokenResponse, error)
    Register(ctx context.Context, req *dto.RegisterRequest) error
}

type authService struct {
    userRepo repository.UserRepository
    jwt      jwt.JWT
}

func NewAuthService(userRepo repository.UserRepository, jwt jwt.JWT) AuthService {
    return &authService{
        userRepo: userRepo,
        jwt:      jwt,
    }
}

func (s *authService) Login(ctx context.Context, req *dto.LoginRequest) (*dto.TokenResponse, error) {
    user, err := s.userRepo.FindByEmail(ctx, req.Email)
    if err != nil {
        return nil, errors.New("invalid credentials")
    }
    
    if !hash.CheckPassword(req.Password, user.Password) {
        return nil, errors.New("invalid credentials")
    }
    
    token, err := s.jwt.Generate(user.ID, user.Role)
    if err != nil {
        return nil, err
    }
    
    return &dto.TokenResponse{
        AccessToken: token,
        TokenType:   "Bearer",
    }, nil
}

// internal/auth/repository/user_repository.go
package repository

import (
    "context"
    
    "github.com/your/project/internal/auth/model"
    "gorm.io/gorm"
)

type UserRepository interface {
    FindByEmail(ctx context.Context, email string) (*model.User, error)
    Create(ctx context.Context, user *model.User) error
}

type userRepository struct {
    db *gorm.DB
}

func NewUserRepository(db *gorm.DB) UserRepository {
    return &userRepository{db: db}
}

func (r *userRepository) FindByEmail(ctx context.Context, email string) (*model.User, error) {
    var user model.User
    err := r.db.WithContext(ctx).Where("email = ?", email).First(&user).Error
    return &user, err
}

func (r *userRepository) Create(ctx context.Context, user *model.User) error {
    return r.db.WithContext(ctx).Create(user).Error
}

// lib/core/network/dio_client.dart
import 'package:dio/dio.dart';

import '../config/env.dart';
import 'interceptors/auth_interceptor.dart';
import 'interceptors/logger_interceptor.dart';

class DioClient {
  late final Dio _dio;
  
  DioClient() {
    _dio = Dio(
      BaseOptions(
        baseUrl: Env.apiBaseUrl,
        connectTimeout: Duration(seconds: 30),
        receiveTimeout: Duration(seconds: 30),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json',
        },
      ),
    );
    
    _dio.interceptors.addAll([
      AuthInterceptor(),
      LoggerInterceptor(),
    ]);
  }
  
  Dio get dio => _dio;
}

// lib/features/auth/presentation/providers/auth_provider.dart
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../../data/repositories/auth_repository_impl.dart';
import '../../domain/entities/user.dart';
import '../../domain/usecases/login_usecase.dart';

final authStateProvider = StateNotifierProvider<AuthNotifier, AuthState>((ref) {
  final loginUseCase = ref.watch(loginUseCaseProvider);
  return AuthNotifier(loginUseCase);
});

class AuthNotifier extends StateNotifier<AuthState> {
  final LoginUseCase _loginUseCase;
  
  AuthNotifier(this._loginUseCase) : super(AuthState.initial());
  
  Future<void> login(String email, String password) async {
    state = state.copyWith(isLoading: true);
    
    final result = await _loginUseCase(email, password);
    
    result.fold(
      (failure) => state = state.copyWith(
        isLoading: false,
        error: failure.message,
      ),
      (user) => state = state.copyWith(
        isLoading: false,
        user: user,
        isAuthenticated: true,
      ),
    );
  }
}

class AuthState {
  final bool isLoading;
  final bool isAuthenticated;
  final User? user;
  final String? error;
  
  AuthState({
    required this.isLoading,
    required this.isAuthenticated,
    this.user,
    this.error,
  });
  
  factory AuthState.initial() => AuthState(
    isLoading: false,
    isAuthenticated: false,
  );
  
  AuthState copyWith({
    bool? isLoading,
    bool? isAuthenticated,
    User? user,
    String? error,
  }) {
    return AuthState(
      isLoading: isLoading ?? this.isLoading,
      isAuthenticated: isAuthenticated ?? this.isAuthenticated,
      user: user ?? this.user,
      error: error ?? this.error,
    );
  }
}

version: '3'

tasks:
  dev:up:
    desc: Start dev services
    cmds:
      - docker compose up -d
  
  dev:down:
    desc: Stop dev services
    cmds:
      - docker compose down -v
  
  dev:air:
    desc: Run backend with live reload
    dir: backend
    cmds:
      - air
  
  db:migrate:up:
    desc: Run database migrations
    dir: backend
    cmds:
      - go run cmd/migrate/main.go up
  
  test:
    desc: Run all tests
    cmds:
      - task: test:backend
      - task: test:frontend
  
  test:backend:
    desc: Run backend tests
    dir: backend
    cmds:
      - go test ./... -v -cover
  
  test:frontend:
    desc: Run frontend tests
    dir: frontend
    cmds:
      - flutter test

# .air.toml
root = "."
testdata_dir = "testdata"
tmp_dir = "tmp"

[build]
  args_bin = []
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ./cmd/api"
  delay = 1000
  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
  exclude_file = []
  exclude_regex = ["_test.go"]
  exclude_unchanged = false
  follow_symlink = false
  full_bin = ""
  include_dir = []
  include_ext = ["go", "tpl", "tmpl", "html"]
  include_file = []
  kill_delay = "0s"
  log = "build-errors.log"
  poll = false
  poll_interval = 0
  rerun = false
  rerun_delay = 500
  send_interrupt = false
  stop_on_error = false

[color]
  app = ""
  build = "yellow"
  main = "magenta"
  runner = "green"
  watcher = "cyan"

[log]
  main_only = false
  time = false

[misc]
  clean_on_exit = false

[screen]
  clear_on_rebuild = false
  keep_scroll = true