proposal_details_page.go

package ui

import (
	"encoding/base64"
	"fmt"
	"os/exec"
	"runtime"

	"gioui.org/layout"
	"gioui.org/unit"
	"gioui.org/widget"
	"gioui.org/widget/material"

	"github.com/planetdecred/dcrlibwallet"
	"github.com/planetdecred/godcr/ui/decredmaterial"
	"github.com/planetdecred/godcr/ui/utils"
	"github.com/planetdecred/godcr/ui/values"
)

const (
	PageProposalDetails = "ProposalDetails"
)

type proposalItemWidgets struct {
	widgets    []layout.Widget
	clickables map[string]*widget.Clickable
}

type proposalDetails struct {
	theme            *decredmaterial.Theme
	line             *decredmaterial.Line
	backButton       decredmaterial.IconButton
	descriptionCard  decredmaterial.Card
	proposalItems    map[string]proposalItemWidgets
	descriptionList  *layout.List
	selectedProposal **dcrlibwallet.Proposal
	redirectIcon     *widget.Image
	redirectButton   *widget.Clickable
	redirectLabel    decredmaterial.Label
	voteBar          decredmaterial.VoteBar
	rejectedIcon     *widget.Icon
	successIcon      *widget.Icon
}

func (win *Window) ProposalDetailsPage(common pageCommon) layout.Widget {
	pg := &proposalDetails{
		theme:            common.theme,
		line:             common.theme.Line(),
		backButton:       common.theme.PlainIconButton(new(widget.Clickable), common.icons.navigationArrowBack),
		descriptionCard:  common.theme.Card(),
		descriptionList:  &layout.List{Axis: layout.Vertical},
		selectedProposal: &win.selectedProposal,
		redirectButton:   new(widget.Clickable),
		redirectIcon:     common.icons.redirectIcon,
		redirectLabel:    common.theme.Body2("View on Politeia"),
		voteBar:          common.theme.VoteBar(common.icons.actionInfo, common.icons.imageBrightness1),
		proposalItems:    make(map[string]proposalItemWidgets),
		rejectedIcon:     common.icons.navigationCancel,
		successIcon:      common.icons.navigationCheck,
	}
	pg.backButton.Color = common.theme.Color.Hint
	pg.backButton.Inset = layout.UniformInset(values.MarginPadding0)
	pg.backButton.Size = values.MarginPadding30
	pg.line.Color = pg.theme.Color.Background

	return func(gtx C) D {
		pg.handle(common)
		return pg.Layout(gtx, common)
	}
}

func (pg *proposalDetails) handle(common pageCommon) {
	for pg.backButton.Button.Clicked() {
		common.ChangePage(PageProposals)
	}

	for token := range pg.proposalItems {
		for location, clickable := range pg.proposalItems[token].clickables {
			if clickable.Clicked() {
				pg.goToURL(location)
			}
		}
	}

	for pg.redirectButton.Clicked() {
		proposal := *pg.selectedProposal
		pg.goToURL("https://proposals.decred.org/proposals/" + proposal.Token)
	}
}

func (pg *proposalDetails) goToURL(url string) {
	var err error

	switch runtime.GOOS {
	case "linux":
		err = exec.Command("xdg-open", url).Start()
	case "windows":
		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
	case "darwin":
		err = exec.Command("open", url).Start()
	default:
		err = fmt.Errorf("unsupported platform")
	}
	if err != nil {
		log.Error(err)
	}
}

func (pg *proposalDetails) layoutLinkButtons(gtx C) D {
	proposal := *pg.selectedProposal

	return layout.Flex{}.Layout(gtx,
		layout.Rigid(func(gtx C) D {
			return pg.backButton.Layout(gtx)
		}),
		layout.Rigid(func(gtx C) D {
			return layout.Inset{Left: values.MarginPadding5}.Layout(gtx, func(gtx C) D {
				return pg.theme.H6(truncateString(proposal.Name, 40)).Layout(gtx)
			})
		}),
		layout.Flexed(1, func(gtx C) D {
			return layout.E.Layout(gtx, func(gtx C) D {
				return material.Clickable(gtx, pg.redirectButton, func(gtx C) D {
					return layout.Flex{}.Layout(gtx,
						layout.Rigid(func(gtx C) D {
							return layout.Inset{Top: values.MarginPadding5}.Layout(gtx, func(gtx C) D {
								return pg.redirectLabel.Layout(gtx)
							})
						}),
						layout.Rigid(func(gtx C) D {
							return pg.redirectIcon.Layout(gtx)
						}),
					)
				})
			})
		}),
	)
}

func (pg *proposalDetails) getProposalText() []byte {
	proposal := *pg.selectedProposal
	desc, _ := base64.StdEncoding.DecodeString(proposal.IndexFile)

	return desc
}

func (pg *proposalDetails) layoutProposalVoteBar(gtx C) D {
	proposal := *pg.selectedProposal

	yes := float32(proposal.YesVotes)
	no := float32(proposal.NoVotes)
	quorumPercent := float32(proposal.QuorumPercentage)
	passPercentage := float32(proposal.PassPercentage)
	eligibleTickets := float32(proposal.EligibleTickets)

	return pg.voteBar.SetParams(yes, no, eligibleTickets, quorumPercent, passPercentage).LayoutWithLegend(gtx)
}

func (pg *proposalDetails) layoutInDiscussionTitle(gtx C, proposal *dcrlibwallet.Proposal) D {
	return D{}
}

func (pg *proposalDetails) layoutVotingTitle(gtx C, proposal *dcrlibwallet.Proposal) D {
	return D{}
}

func (pg *proposalDetails) layoutNormalTitle(gtx C, proposal *dcrlibwallet.Proposal) D {
	var label decredmaterial.Label
	var icon *widget.Icon
	switch proposal.Category {
	case dcrlibwallet.ProposalCategoryApproved:
		label = pg.theme.Body2("Approved")
		icon = pg.successIcon
		icon.Color = pg.theme.Color.Success
	case dcrlibwallet.ProposalCategoryRejected:
		label = pg.theme.Body2("Rejected")
		icon = pg.rejectedIcon
		icon.Color = pg.theme.Color.Danger
	case dcrlibwallet.ProposalCategoryAbandoned:
		label = pg.theme.Body2("Abandoned")
	}
	timeagoLabel := pg.theme.Body2(timeAgo(proposal.Timestamp))

	return layout.Flex{}.Layout(gtx,
		layout.Rigid(func(gtx C) D {
			if icon == nil {
				return D{}
			}
			return icon.Layout(gtx, unit.Dp(20))
		}),
		layout.Rigid(func(gtx C) D {
			return layout.Inset{Left: values.MarginPadding5}.Layout(gtx, label.Layout)
		}),
		layout.Flexed(1, func(gtx C) D {
			return layout.E.Layout(gtx, timeagoLabel.Layout)
		}),
	)
}

func (pg *proposalDetails) layoutTitle(gtx C) D {
	proposal := *pg.selectedProposal

	return pg.descriptionCard.Layout(gtx, func(gtx C) D {
		return layout.UniformInset(values.MarginPadding15).Layout(gtx, func(gtx C) D {
			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
				layout.Rigid(func(gtx C) D {
					if proposal.Category == dcrlibwallet.ProposalCategoryPre {
						return pg.layoutInDiscussionTitle(gtx, proposal)
					} else if proposal.Category == dcrlibwallet.ProposalCategoryActive {
						return pg.layoutVotingTitle(gtx, proposal)
					}
					return pg.layoutNormalTitle(gtx, proposal)
				}),
				layout.Rigid(func(gtx C) D {
					return layout.Inset{Top: values.MarginPadding10, Bottom: values.MarginPadding10}.Layout(gtx, func(gtx C) D {
						return pg.line.Layout(gtx)
					})
				}),
				layout.Rigid(func(gtx C) D {
					if proposal.Category == dcrlibwallet.ProposalCategoryActive ||
						proposal.Category == dcrlibwallet.ProposalCategoryApproved ||
						proposal.Category == dcrlibwallet.ProposalCategoryRejected {
						return pg.layoutProposalVoteBar(gtx)
					}
					return D{}
				}),
			)
		})
	})
}

func (pg *proposalDetails) layoutDescription(gtx C) D {
	proposal := *pg.selectedProposal
	dotLabel := pg.theme.H4(" . ")
	userLabel := pg.theme.Body2(proposal.Username)
	versionLabel := pg.theme.Body2("Version " + proposal.Version)
	publishedLabel := pg.theme.Body2("Published " + timeAgo(proposal.PublishedAt))
	updatedLabel := pg.theme.Body2("Updated " + timeAgo(proposal.Timestamp))

	w := []layout.Widget{
		func(gtx C) D {
			return layout.Inset{
				Top:    values.MarginPadding5,
				Bottom: values.MarginPadding10,
			}.Layout(gtx, func(gtx C) D {
				return pg.theme.H5(proposal.Name).Layout(gtx)
			})
		},
		func(gtx C) D {
			pg.line.Width = gtx.Constraints.Max.X
			return pg.line.Layout(gtx)
		},
		func(gtx C) D {
			return layout.Inset{
				Top:    values.MarginPadding15,
				Bottom: values.MarginPadding15,
			}.Layout(gtx, func(gtx C) D {
				return layout.Flex{}.Layout(gtx,
					layout.Rigid(userLabel.Layout),
					layout.Rigid(func(gtx C) D {
						return layout.Inset{Top: unit.Dp(-23)}.Layout(gtx, dotLabel.Layout)
					}),
					layout.Rigid(publishedLabel.Layout),
					layout.Rigid(func(gtx C) D {
						return layout.Inset{Top: unit.Dp(-23)}.Layout(gtx, dotLabel.Layout)
					}),
					layout.Rigid(versionLabel.Layout),
					layout.Rigid(func(gtx C) D {
						return layout.Inset{Top: unit.Dp(-23)}.Layout(gtx, dotLabel.Layout)
					}),
					layout.Rigid(updatedLabel.Layout),
				)
			})
		},
		func(gtx C) D {
			pg.line.Width = gtx.Constraints.Max.X
			return pg.line.Layout(gtx)
		},
	}

	if item, ok := pg.proposalItems[proposal.Token]; ok {
		w = append(w, item.widgets...)
	} else {
		r := utils.RenderMarkdown(gtx, pg.theme, pg.getProposalText())
		proposalWidgets, proposalClickables := r.Layout()
		pg.proposalItems[proposal.Token] = proposalItemWidgets{
			widgets:    proposalWidgets,
			clickables: proposalClickables,
		}
		w = append(w, proposalWidgets...)
	}

	return pg.descriptionCard.Layout(gtx, func(gtx C) D {
		return layout.UniformInset(values.MarginPadding15).Layout(gtx, func(gtx C) D {
			return pg.descriptionList.Layout(gtx, len(w), func(gtx C, i int) D {
				return layout.UniformInset(unit.Dp(0)).Layout(gtx, w[i])
			})
		})
	})
}

func (pg *proposalDetails) Layout(gtx C, common pageCommon) D {
	return common.Layout(gtx, func(gtx C) D {
		return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
			layout.Rigid(func(gtx C) D {
				return pg.layoutLinkButtons(gtx)
			}),
			layout.Rigid(func(gtx C) D {
				return layout.Inset{
					Top:    unit.Dp(-30),
					Bottom: values.MarginPadding10,
				}.Layout(gtx, func(gtx C) D {
					return pg.layoutTitle(gtx)
				})
			}),
			layout.Rigid(func(gtx C) D {
				return pg.layoutDescription(gtx)
			}),
		)
	})
}