MVP & MVVM Architecture #

// mvp/article/view_contract.go — Contract between View and Presenter
package article

// ArticleListView is the interface implemented by the View
// ✓ The Presenter only knows this interface — not the UI implementation
type ArticleListView interface {
	ShowArticles(articles []ArticleViewModel)
	ShowError(message string)
	ShowLoading()
	HideLoading()
	ShowEmptyState()
	NavigateToDetail(articleID int64)
}

// ArticleDetailView is the contract for the article detail page
type ArticleDetailView interface {
	ShowArticle(article ArticleDetailViewModel)
	ShowError(message string)
	ShowLoading()
	HideLoading()
	ShowPublishSuccess()
	ShowPublishError(reason string)
}

// ArticleViewModel is the View Model — data already formatted for display
// ✓ Not a domain entity — only data ready for the View to display
type ArticleViewModel struct {
	ID              int64
	Title           string
	Excerpt         string     // first 150 characters of the body
	AuthorName      string
	PublishedAtText string     // "2 days ago" instead of time.Time
	IsPublished     bool
}

type ArticleDetailViewModel struct {
	ID              int64
	Title           string
	Body            string
	AuthorName      string
	PublishedAtText string
	CanPublish      bool      // true if the user has permission
	CanEdit         bool
}

// mvp/article/presenter.go — Presenter: all UI logic lives here
package article

import (
	"context"
	"fmt"
	"time"

	"myapp/domain"
	"myapp/service"
)

// ArticleListPresenter manages the logic for the article list page
// ✓ No imports from any UI framework
// ✓ Can be tested with a mock View
type ArticleListPresenter struct {
	view        ArticleListView
	articleSvc  service.ArticleService
	currentUser *domain.User
}

func NewArticleListPresenter(
	view ArticleListView,
	svc service.ArticleService,
	user *domain.User,
) *ArticleListPresenter {
	return &ArticleListPresenter{
		view:        view,
		articleSvc:  svc,
		currentUser: user,
	}
}

// LoadArticles is called when the View needs to display the article list
// ✓ The Presenter orchestrates loading, error, and success states
func (p *ArticleListPresenter) LoadArticles(ctx context.Context) {
	p.view.ShowLoading()

	articles, err := p.articleSvc.FindPublished(ctx)

	p.view.HideLoading()

	if err != nil {
		p.view.ShowError("Failed to load articles: " + err.Error())
		return
	}

	if len(articles) == 0 {
		p.view.ShowEmptyState()
		return
	}

	// Map domain objects to View Models — formatting happens in the Presenter
	viewModels := make([]ArticleViewModel, len(articles))
	for i, a := range articles {
		viewModels[i] = ArticleViewModel{
			ID:              a.ID,
			Title:           a.Title,
			Excerpt:         truncate(a.Body, 150),
			AuthorName:      a.Author.FullName,
			PublishedAtText: timeAgo(a.PublishedAt),
			IsPublished:     a.IsPublished(),
		}
	}

	p.view.ShowArticles(viewModels)
}

// OnArticleTapped is called when the user taps an article
func (p *ArticleListPresenter) OnArticleTapped(articleID int64) {
	p.view.NavigateToDetail(articleID)
}

// ArticleDetailPresenter manages the logic for the article detail page
type ArticleDetailPresenter struct {
	view       ArticleDetailView
	articleSvc service.ArticleService
	user       *domain.User
	articleID  int64
}

func NewArticleDetailPresenter(
	view ArticleDetailView,
	svc service.ArticleService,
	user *domain.User,
	articleID int64,
) *ArticleDetailPresenter {
	return &ArticleDetailPresenter{
		view:       view,
		articleSvc: svc,
		user:       user,
		articleID:  articleID,
	}
}

func (p *ArticleDetailPresenter) Load(ctx context.Context) {
	p.view.ShowLoading()

	article, err := p.articleSvc.FindByID(ctx, p.articleID)

	p.view.HideLoading()

	if err != nil {
		p.view.ShowError("Article not found")
		return
	}

	// Determine permissions — presentation logic lives in the Presenter
	canPublish := !article.IsPublished() && p.user.HasRole("editor")
	canEdit := p.user.HasRole("editor") || p.user.ID == article.AuthorID

	p.view.ShowArticle(ArticleDetailViewModel{
		ID:              article.ID,
		Title:           article.Title,
		Body:            article.Body,
		AuthorName:      article.Author.FullName,
		PublishedAtText: timeAgo(article.PublishedAt),
		CanPublish:      canPublish,
		CanEdit:         canEdit,
	})
}

func (p *ArticleDetailPresenter) OnPublishTapped(ctx context.Context) {
	p.view.ShowLoading()

	_, err := p.articleSvc.Publish(ctx, p.articleID)

	p.view.HideLoading()

	if err != nil {
		p.view.ShowPublishError(err.Error())
		return
	}

	p.view.ShowPublishSuccess()
	// Reload the article to update the display
	p.Load(ctx)
}

// Helper functions — formatting logic lives in the Presenter, not the View
func truncate(s string, maxLen int) string {
	if len(s) <= maxLen {
		return s
	}
	return s[:maxLen] + "..."
}

func timeAgo(t *time.Time) string {
	if t == nil {
		return "Not published"
	}
	diff := time.Since(*t)
	switch {
	case diff < time.Minute:
		return "Just now"
	case diff < time.Hour:
		return fmt.Sprintf("%d minutes ago", int(diff.Minutes()))
	case diff < 24*time.Hour:
		return fmt.Sprintf("%d hours ago", int(diff.Hours()))
	default:
		return fmt.Sprintf("%d days ago", int(diff.Hours()/24))
	}
}

// mvp/article/presenter_test.go
package article_test

import (
	"context"
	"testing"

	"myapp/domain"
	"myapp/mvp/article"
)

// MockArticleListView implements ArticleListView for testing
type MockArticleListView struct {
	articles     []article.ArticleViewModel
	errorMessage string
	isLoading    bool
	showedEmpty  bool
}

func (m *MockArticleListView) ShowArticles(articles []article.ArticleViewModel) {
	m.articles = articles
}
func (m *MockArticleListView) ShowError(msg string)         { m.errorMessage = msg }
func (m *MockArticleListView) ShowLoading()                 { m.isLoading = true }
func (m *MockArticleListView) HideLoading()                 { m.isLoading = false }
func (m *MockArticleListView) ShowEmptyState()              { m.showedEmpty = true }
func (m *MockArticleListView) NavigateToDetail(id int64)    {}

// MockArticleService
type MockArticleService struct {
	articles []*domain.Article
	err      error
}

func (m *MockArticleService) FindPublished(ctx context.Context) ([]*domain.Article, error) {
	return m.articles, m.err
}

// ✓ This test needs no browser, no HTTP server, no database
func TestArticleListPresenter_LoadArticles_Success(t *testing.T) {
	now := time.Now()
	mockView := &MockArticleListView{}
	mockSvc := &MockArticleService{
		articles: []*domain.Article{
			{ID: 1, Title: "First Article", Body: "Article body...", PublishedAt: &now},
			{ID: 2, Title: "Second Article", Body: "Second article body...", PublishedAt: &now},
		},
	}

	presenter := article.NewArticleListPresenter(mockView, mockSvc, &domain.User{})
	presenter.LoadArticles(context.Background())

	// Verify the View received the correct data
	if len(mockView.articles) != 2 {
		t.Errorf("expected 2 articles, got %d", len(mockView.articles))
	}
	if mockView.isLoading {
		t.Error("loading must be hidden after completion")
	}
	if mockView.articles[0].Title != "First Article" {
		t.Errorf("title does not match: %s", mockView.articles[0].Title)
	}
}

func TestArticleListPresenter_LoadArticles_Empty(t *testing.T) {
	mockView := &MockArticleListView{}
	mockSvc := &MockArticleService{articles: nil}

	presenter := article.NewArticleListPresenter(mockView, mockSvc, &domain.User{})
	presenter.LoadArticles(context.Background())

	if !mockView.showedEmpty {
		t.Error("must show the empty state when there are no articles")
	}
}

// mvvm/article/viewmodel.go — ViewModel: state + presentation logic
package article

import (
	"context"
	"sync"
	"time"
)

// ArticleListState represents the entire UI state of the list page
// ✓ The ViewModel knows nothing about the UI framework — it only manages state
type ArticleListState struct {
	IsLoading bool
	Articles  []ArticleViewModel
	Error     string
	IsEmpty   bool
}

// ArticleViewModel is data ready for the View to display
type ArticleViewModel struct {
	ID              int64
	Title           string
	Excerpt         string
	AuthorName      string
	PublishedAtText string
}

// Observer is the function called when state changes
type Observer func(state ArticleListState)

// ArticleListViewModel manages state and notifies observers when it changes
type ArticleListViewModel struct {
	mu         sync.RWMutex
	state      ArticleListState
	observers  []Observer
	articleSvc ArticleService
}

func NewArticleListViewModel(svc ArticleService) *ArticleListViewModel {
	return &ArticleListViewModel{articleSvc: svc}
}

// Subscribe registers an observer — the View registers itself here
func (vm *ArticleListViewModel) Subscribe(observer Observer) {
	vm.mu.Lock()
	defer vm.mu.Unlock()
	vm.observers = append(vm.observers, observer)
}

// notify tells all observers that the state has changed
func (vm *ArticleListViewModel) notify() {
	vm.mu.RLock()
	state := vm.state
	observers := vm.observers
	vm.mu.RUnlock()

	for _, observer := range observers {
		observer(state) // ✓ the View reacts automatically
	}
}

// setState changes the state and immediately notifies observers
func (vm *ArticleListViewModel) setState(mutate func(*ArticleListState)) {
	vm.mu.Lock()
	mutate(&vm.state)
	vm.mu.Unlock()
	vm.notify()
}

// LoadArticles is an action the View can call
func (vm *ArticleListViewModel) LoadArticles(ctx context.Context) {
	vm.setState(func(s *ArticleListState) {
		s.IsLoading = true
		s.Error = ""
	})

	articles, err := vm.articleSvc.FindPublished(ctx)

	if err != nil {
		vm.setState(func(s *ArticleListState) {
			s.IsLoading = false
			s.Error = "Failed to load articles"
		})
		return
	}

	viewModels := make([]ArticleViewModel, len(articles))
	for i, a := range articles {
		viewModels[i] = ArticleViewModel{
			ID:              a.ID,
			Title:           a.Title,
			Excerpt:         truncate(a.Body, 150),
			AuthorName:      a.AuthorName,
			PublishedAtText: timeAgo(a.PublishedAt),
		}
	}

	vm.setState(func(s *ArticleListState) {
		s.IsLoading = false
		s.Articles = viewModels
		s.IsEmpty = len(viewModels) == 0
	})
}

// CurrentState returns the current state — for initial synchronization
func (vm *ArticleListViewModel) CurrentState() ArticleListState {
	vm.mu.RLock()
	defer vm.mu.RUnlock()
	return vm.state
}

// mvvp/article/view_presenter.go — View Presenter with explicit UI state
package article

import (
	"context"
	"sync"
)

// UIState stores all state needed to render the View
type UIState struct {
	IsLoading    bool
	IsRefreshing bool
	CurrentPage  int
	TotalPages   int
	SearchQuery  string
	SortBy       string
	Articles     []ArticleViewModel
	ErrorMessage string
}

// ArticleListViewPresenter is the View Presenter for the article list page
// ✓ More stateful than a regular MVP Presenter
// ✓ Manages pagination, search, filters — all UI state lives here
type ArticleListViewPresenter struct {
	mu    sync.RWMutex
	view  ArticleListView
	svc   ArticleService
	state UIState
}

func NewArticleListViewPresenter(view ArticleListView, svc ArticleService) *ArticleListViewPresenter {
	return &ArticleListViewPresenter{
		view:  view,
		svc:   svc,
		state: UIState{CurrentPage: 1, SortBy: "created_at"},
	}
}

// OnSearchQueryChanged is called when the user changes the search query
func (p *ArticleListViewPresenter) OnSearchQueryChanged(ctx context.Context, query string) {
	p.mu.Lock()
	p.state.SearchQuery = query
	p.state.CurrentPage = 1 // reset to the first page when searching
	p.mu.Unlock()

	p.loadArticles(ctx)
}

// OnSortChanged is called when the user changes the sort order
func (p *ArticleListViewPresenter) OnSortChanged(ctx context.Context, sortBy string) {
	p.mu.Lock()
	p.state.SortBy = sortBy
	p.state.CurrentPage = 1
	p.mu.Unlock()

	p.loadArticles(ctx)
}

// OnNextPageTapped is called when the user presses the next page button
func (p *ArticleListViewPresenter) OnNextPageTapped(ctx context.Context) {
	p.mu.RLock()
	currentPage := p.state.CurrentPage
	totalPages := p.state.TotalPages
	p.mu.RUnlock()

	if currentPage >= totalPages {
		return // already on the last page
	}

	p.mu.Lock()
	p.state.CurrentPage++
	p.mu.Unlock()

	p.loadArticles(ctx)
}

// OnRefresh is called when the user pull-to-refreshes
func (p *ArticleListViewPresenter) OnRefresh(ctx context.Context) {
	p.mu.Lock()
	p.state.IsRefreshing = true
	p.state.CurrentPage = 1
	p.mu.Unlock()

	p.view.ShowRefreshing()
	p.loadArticles(ctx)
}

func (p *ArticleListViewPresenter) loadArticles(ctx context.Context) {
	p.mu.RLock()
	query := p.state.SearchQuery
	page := p.state.CurrentPage
	sortBy := p.state.SortBy
	p.mu.RUnlock()

	p.view.ShowLoading()

	result, err := p.svc.Search(ctx, SearchParams{
		Query:  query,
		Page:   page,
		SortBy: sortBy,
	})

	p.view.HideLoading()
	p.view.HideRefreshing()

	if err != nil {
		p.mu.Lock()
		p.state.ErrorMessage = err.Error()
		p.state.IsRefreshing = false
		p.mu.Unlock()

		p.view.ShowError(err.Error())
		return
	}

	p.mu.Lock()
	p.state.Articles = toViewModels(result.Articles)
	p.state.TotalPages = result.TotalPages
	p.state.ErrorMessage = ""
	p.state.IsRefreshing = false
	p.mu.Unlock()

	p.view.ShowArticles(p.state.Articles)
	p.view.UpdatePagination(page, result.TotalPages)
}

// GetCurrentState returns a snapshot of the current state
func (p *ArticleListViewPresenter) GetCurrentState() UIState {
	p.mu.RLock()
	defer p.mu.RUnlock()
	return p.state
}

// ✗ God Presenter — a Presenter that is too large, knowing about too many things
type ArticlePresenter struct {
	// ✗ The Presenter holds dependencies to every service
	articleSvc  ArticleService
	userSvc     UserService
	commentSvc  CommentService
	analyticsEv AnalyticsEventTracker
	paymentSvc  PaymentService
	// This is a sign the Presenter needs to be split
}

// ✓ Split into several smaller Presenters
type ArticleListPresenter struct { articleSvc ArticleService }
type ArticleDetailPresenter struct { articleSvc ArticleService; commentSvc CommentService }
type ArticleAnalyticsPresenter struct { analyticsEv AnalyticsEventTracker }

// ✗ The View making decisions on its own — not passive
// In Android/mobile
class ArticleListView {
    fun showArticles(articles: List<Article>) {
        // ✗ the View formats data itself
        articles.forEach { article ->
            val text = if (article.isPublished) "✓ ${article.title}" else article.title
            // ...
        }
    }
}

// ✓ The Presenter formats — the View only renders what is ready
class ArticleListPresenter {
    fun loadArticles() {
        val articles = service.findPublished()
        val viewModels = articles.map { article ->
            ArticleViewModel(
                displayTitle = if (article.isPublished) "✓ ${article.title}" else article.title
            )
        }
        view.showArticles(viewModels) // ✓ the view only renders ready data
    }
}

// ✗ The Presenter importing a UI framework — hard to test
// ✗ import android.view.View — the Presenter depends on the Android framework
// ✗ import UIKit — the Presenter depends on the iOS framework

// ✓ The Presenter only depends on interfaces (View Contracts)
// Interfaces do not depend on any UI framework
// The Presenter can be tested with mocks implementing the interface

// ✗ Business logic in the Presenter
type ArticlePresenter struct{}

func (p *ArticlePresenter) OnPublishTapped(ctx context.Context, articleID int64) {
	article, _ := p.svc.FindByID(ctx, articleID)
	// ✗ Business rule in the Presenter — should be in the domain/service
	if len(article.Body) < 100 {
		p.view.ShowError("article is too short to publish")
		return
	}
	if article.AuthorID != p.currentUser.ID {
		p.view.ShowError("you are not the author of this article")
		return
	}
	// ...
}

// ✓ Business logic in the domain/service — the Presenter only coordinates
func (p *ArticlePresenter) OnPublishTapped(ctx context.Context, articleID int64) {
	_, err := p.articleSvc.Publish(ctx, articleID) // ✓ business rule in the service
	if err != nil {
		p.view.ShowPublishError(err.Error())
		return
	}
	p.view.ShowPublishSuccess()
}